AWS.BedrockRuntime — AWS SDK for JavaScript (original) (raw)

Examples:

Node.js EventStream Example

// In Node.js, events are streamed and can be read as they arrive.
bedrockruntime.converseStream({/** params **/}, function(err, data) {
  if (err) {
    // handle error
    return console.error(err);
  }

  var eventStream = data.stream;

  eventStream.on('data', function(event) {
    // Check the top-level field to determine which event this is.
    if (event.messageStart) {
      // handle messageStart event
    } else if (event.contentBlockStart) {
      // handle contentBlockStart event
    } else if (event.contentBlockDelta) {
      // handle contentBlockDelta event
    } else if (event.contentBlockStop) {
      // handle contentBlockStop event
    } else if (event.messageStop) {
      // handle messageStop event
    } else if (event.metadata) {
      // handle metadata event
    } else if (event.internalServerException) {
      // handle internalServerException event
    } else if (event.modelStreamErrorException) {
      // handle modelStreamErrorException event
    } else if (event.validationException) {
      // handle validationException event
    } else if (event.throttlingException) {
      // handle throttlingException event
    } else if (event.serviceUnavailableException) {
      // handle serviceUnavailableException event
    }
  });
  eventStream.on('error', function(err) { /** Handle error events **/});
  eventStream.on('end', function() { /** Finished reading all events **/});
});

Browser EventStream Example

// In browsers, events aren't processed until the response is fully buffered.
// Events will be accessible as an array.
bedrockruntime.converseStream({/** params **/}, function(err, data) {
  if (err) {
    // handle error
    return console.error(err);
  }

  var events = data.stream;

  for (var event of events) {
    // Check the top-level field to determine which event this is.
    if (event.messageStart) {
      // handle messageStart event
    } else if (event.contentBlockStart) {
      // handle contentBlockStart event
    } else if (event.contentBlockDelta) {
      // handle contentBlockDelta event
    } else if (event.contentBlockStop) {
      // handle contentBlockStop event
    } else if (event.messageStop) {
      // handle messageStop event
    } else if (event.metadata) {
      // handle metadata event
    } else if (event.internalServerException) {
      // handle internalServerException event
    } else if (event.modelStreamErrorException) {
      // handle modelStreamErrorException event
    } else if (event.validationException) {
      // handle validationException event
    } else if (event.throttlingException) {
      // handle throttlingException event
    } else if (event.serviceUnavailableException) {
      // handle serviceUnavailableException event
    }
  }
});

Async Iterator EventStream Example (Experimental)

// In Node.js v10.x, Readable streams have experimental support for async iteration.
// Instead of listening to the event stream's 'data' event, you can use a for...await loop.
async function example() {
  try {
    const result = await bedrockruntime.converseStream({/** params **/}).promise();

    const events = result.stream;

    for await (const event of events) {
      // Check the top-level field to determine which event this is.
      if (event.messageStart) {
        // handle messageStart event
      } else if (event.contentBlockStart) {
        // handle contentBlockStart event
      } else if (event.contentBlockDelta) {
        // handle contentBlockDelta event
      } else if (event.contentBlockStop) {
        // handle contentBlockStop event
      } else if (event.messageStop) {
        // handle messageStop event
      } else if (event.metadata) {
        // handle metadata event
      } else if (event.internalServerException) {
        // handle internalServerException event
      } else if (event.modelStreamErrorException) {
        // handle modelStreamErrorException event
      } else if (event.validationException) {
        // handle validationException event
      } else if (event.throttlingException) {
        // handle throttlingException event
      } else if (event.serviceUnavailableException) {
        // handle serviceUnavailableException event
      }
    }
  } catch (err) {
    // handle error
  }
}

Calling the converseStream operation

var params = {
  messages: [ /* required */
    {
      content: [ /* required */
        {
          document: {
            format: pdf | csv | doc | docx | xls | xlsx | html | txt | md, /* required */
            name: 'STRING_VALUE', /* required */
            source: { /* required */
              bytes: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */
            }
          },
          guardContent: {
            text: {
              text: 'STRING_VALUE', /* required */
              qualifiers: [
                grounding_source | query | guard_content,
                /* more items */
              ]
            }
          },
          image: {
            format: png | jpeg | gif | webp, /* required */
            source: { /* required */
              bytes: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */
            }
          },
          text: 'STRING_VALUE',
          toolResult: {
            content: [ /* required */
              {
                document: {
                  format: pdf | csv | doc | docx | xls | xlsx | html | txt | md, /* required */
                  name: 'STRING_VALUE', /* required */
                  source: { /* required */
                    bytes: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */
                  }
                },
                image: {
                  format: png | jpeg | gif | webp, /* required */
                  source: { /* required */
                    bytes: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */
                  }
                },
                json: {
                },
                text: 'STRING_VALUE'
              },
              /* more items */
            ],
            toolUseId: 'STRING_VALUE', /* required */
            status: success | error
          },
          toolUse: {
            input: { /* required */
            },
            name: 'STRING_VALUE', /* required */
            toolUseId: 'STRING_VALUE' /* required */
          }
        },
        /* more items */
      ],
      role: user | assistant /* required */
    },
    /* more items */
  ],
  modelId: 'STRING_VALUE', /* required */
  additionalModelRequestFields: {
  },
  additionalModelResponseFieldPaths: [
    'STRING_VALUE',
    /* more items */
  ],
  guardrailConfig: {
    guardrailIdentifier: 'STRING_VALUE', /* required */
    guardrailVersion: 'STRING_VALUE', /* required */
    streamProcessingMode: sync | async,
    trace: enabled | disabled
  },
  inferenceConfig: {
    maxTokens: 'NUMBER_VALUE',
    stopSequences: [
      'STRING_VALUE',
      /* more items */
    ],
    temperature: 'NUMBER_VALUE',
    topP: 'NUMBER_VALUE'
  },
  system: [
    {
      guardContent: {
        text: {
          text: 'STRING_VALUE', /* required */
          qualifiers: [
            grounding_source | query | guard_content,
            /* more items */
          ]
        }
      },
      text: 'STRING_VALUE'
    },
    /* more items */
  ],
  toolConfig: {
    tools: [ /* required */
      {
        toolSpec: {
          inputSchema: { /* required */
            json: {
            }
          },
          name: 'STRING_VALUE', /* required */
          description: 'STRING_VALUE'
        }
      },
      /* more items */
    ],
    toolChoice: {
      any: {
      },
      auto: {
      },
      tool: {
        name: 'STRING_VALUE' /* required */
      }
    }
  }
};
bedrockruntime.converseStream(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});