How to Build a GPT‑6 Astra Chatbot on Amazon Bedrock Using Node.js 22’s Native TypeScript Stripping, Explained Simply

node --experimental-strip-types chat.ts

// chat.ts – run with `node --experimental-strip-types chat.ts`

// Import only what we need – no heavy SDKs here.
import { fromIni } from "@aws-sdk/credential-provider-ini";
import { SignatureV4 } from "@aws-sdk/signature-v4";
import { Sha256 } from "@aws-crypto/sha256-js";

// The region where your Bedrock model lives.
const REGION = "us-east-1";

https://bedrock-runtime.<region>.amazonaws.com/model/gpt-6-astra/invoke

/**
 * Build a signed fetch request for Bedrock.
 *
 * @param body   The JSON payload we want to POST.
 * @returns      A ready‑to‑use Request object with Authorization headers.
 */
async function buildSignedRequest(body: Record<string, unknown>): Promise<Request> {
  // 1️⃣ Load credentials – here we use the shared INI file (~/.aws/credentials)
  const credentials = await fromIni({ profile: "default" })();

  // 2️⃣ Create a SigV4 signer for the Bedrock service
  const signer = new SignatureV4({
    credentials,
    service: "bedrock-runtime",
    region: REGION,
    sha256: Sha256,
  });

  // 3️⃣ Assemble the raw HTTP request data (method, URL, headers, body)
  const url = `https://bedrock-runtime.${REGION}.amazonaws.com/model/gpt-6-astra/invoke`;
  const request = new Request(url, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      // Bedrock requires a short user‑agent; keep it simple.
      "User-Agent": "bedrock-chatbot-demo/1.0",
    },
    body: JSON.stringify(body),
  });

  // 4️⃣ Let the signer add the Authorization header and related X‑Amz‑* headers.
  const signed = await signer.sign(request, { signingDate: new Date() });

  return signed;
}

const payload = {
  // “messages” follows the chat format: role (system, user, assistant) + content.
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What’s the capital of France?" },
  ],
  // Optional: max tokens, temperature, etc.
  max_tokens: 512,
  temperature: 0.7,
};

async function invokeBedrock(payload: Record<string, unknown>) {
  const signedRequest = await buildSignedRequest(payload);
  // Native fetch returns a Response object we can stream from.
  return fetch(signedRequest);
}

{"type":"message","content":"Paris"}
{"type":"end"}

/**
 * Consume a streaming NDJSON response and call `onChunk` for each parsed object.
 *
 * @param response   The fetch Response whose body is a readable stream.
 * @param onChunk    Callback invoked with each JSON object.
 */
async function handleNdjsonStream(
  response: Response,
  onChunk: (obj: any) => void
): Promise<void> {
  // The body is a WHATWG ReadableStream.
  const reader = response.body?.getReader();
  if (!reader) throw new Error("Response body is not a stream.");

  const decoder = new TextDecoder("utf-8");
  let buffer = "";

  // Loop until the stream signals “done”.
  while (true) {
    const { value, done } = await reader.read();
    if (done) break; // No more bytes.

    // Convert Uint8Array → string and append to our buffer.
    buffer += decoder.decode(value, { stream: true });

    // Split on newline – keep any partial line for the next chunk.
    const lines = buffer.split("\n");
    // The last element may be incomplete, so keep it in `buffer`.
    buffer = lines.pop()!;

    for (const line of lines) {
      if (!line.trim()) continue; // Skip empty lines.
      try {
        const obj = JSON.parse(line);
        onChunk(obj);
      } catch (e) {
        console.warn("Failed to parse line:", line);
      }
    }
  }

  // If anything remains after the loop, try to parse it.
  if (buffer.trim()) {
    try {
      onChunk(JSON.parse(buffer));
    } catch {
      // Silently ignore – usually nothing left.
    }
  }
}

function collectAnswer() {
  let answer = "";
  return (chunk: any) => {
    if (chunk.type === "message") {
      answer += chunk.content;
    } else if (chunk.type === "end") {
      console.log("\nAssistant:", answer.trim());
    }
  };
}

// chat.ts – run with: node --experimental-strip-types chat.ts

import { fromIni } from "@aws-sdk/credential-provider-ini";
import { SignatureV4 } from "@aws-sdk/signature-v4";
import { Sha256 } from "@aws-crypto/sha256-js";

// ---------- Configuration ----------
const REGION = "us-east-1"; // Change if your model lives elsewhere.

// ---------- Helper: Build a signed request ----------
async function buildSignedRequest(body: Record<string, unknown>): Promise<Request> {
  const credentials = await fromIni({ profile: "default" })();
  const signer = new SignatureV4({
    credentials,
    service: "bedrock-runtime",
    region: REGION,
    sha256: Sha256,
  });

  const url = `https://bedrock-runtime.${REGION}.amazonaws.com/model/gpt-6-astra/invoke`;
  const request = new Request(url, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "User-Agent": "bedrock-chatbot-demo/1.0",
    },
    body: JSON.stringify(body),
  });

  return signer.sign(request, { signingDate: new Date() });
}

// ---------- Helper: Stream NDJSON ----------
async function handleNdjsonStream(
  response: Response,
  onChunk: (obj: any) => void
): Promise<void> {
  const reader = response.body?.getReader();
  if (!reader) throw new Error("No streaming body.");

  const decoder = new TextDecoder("utf-8");
  let buffer = "";

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });

    const lines = buffer.split("\n");
    buffer = lines.pop()!; // Keep incomplete line.

    for (const line of lines) {
      if (!line.trim()) continue;
      try {
        onChunk(JSON.parse(line));
      } catch {
        console.warn("Bad line:", line);
      }
    }
  }

  if (buffer.trim()) {
    try {
      onChunk(JSON.parse(buffer));
    } catch {
      // ignore final stray data
    }
  }
}

// ---------- Main chatbot logic ----------
async function chat() {
  // Read user input from stdin.
  const prompt = await new Promise<string>((resolve) => {
    process.stdout.write("You: ");
    process.stdin.once("data", (data) => resolve(data.toString().trim()));
  });

  // Build the payload – Bedrock expects a `messages` array.
  const payload = {
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: prompt },
    ],
    max_tokens: 1024,
    temperature: 0.6,
  };

  // Sign and send the request.
  const signedReq = await buildSignedRequest(payload);
  const response = await fetch(signedReq);

  if (!response.ok) {
    const err = await response.text();
    throw new Error(`Bedrock error ${response.status}: ${err}`);
  }

  // Collect and print the assistant’s answer.
  const printAnswer = collectAnswer();
  await handleNdjsonStream(response, printAnswer);
}

// Helper that builds the answer string and logs it once finished.
function collectAnswer() {
  let answer = "";
  return (chunk: any) => {
    if (chunk.type === "message") {
      answer += chunk.content;
    } else if (chunk.type === "end") {
      console.log("\nAssistant:", answer.trim());
    }
  };
}

// Run the chatbot.
chat().catch((e) => console.error("Error:", e));