mirror of
https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web.git
synced 2025-10-14 14:03:41 +08:00
修改： app/api/[provider]/[...path]/route.ts
修改： app/api/auth.ts 新文件： app/api/bedrock.ts 新文件： app/api/bedrock/models.ts 新文件： app/api/bedrock/utils.ts 修改： app/client/api.ts 新文件： app/client/platforms/bedrock.ts 修改： app/components/settings.tsx 修改： app/config/server.ts 修改： app/constant.ts 修改： app/locales/cn.ts 修改： app/locales/en.ts 修改： app/store/access.ts 修改： app/utils.ts 修改： package.json
This commit is contained in:
glay
@@ -1,6 +1,7 @@
|
||||
import { ApiPath } from "@/app/constant";
|
||||
import { NextRequest } from "next/server";
|
||||
import { handle as openaiHandler } from "../../openai";
|
||||
import { handle as bedrockHandler } from "../../bedrock";
|
||||
import { handle as azureHandler } from "../../azure";
|
||||
import { handle as googleHandler } from "../../google";
|
||||
import { handle as anthropicHandler } from "../../anthropic";
|
||||
@@ -20,12 +21,15 @@ async function handle(
|
||||
const apiPath = `/api/${params.provider}`;
|
||||
console.log(`[${params.provider} Route] params `, params);
|
||||
switch (apiPath) {
|
||||
case ApiPath.Bedrock:
|
||||
return bedrockHandler(req, { params });
|
||||
case ApiPath.Azure:
|
||||
return azureHandler(req, { params });
|
||||
case ApiPath.Google:
|
||||
return googleHandler(req, { params });
|
||||
case ApiPath.Anthropic:
|
||||
return anthropicHandler(req, { params });
|
||||
|
||||
case ApiPath.Baidu:
|
||||
return baiduHandler(req, { params });
|
||||
case ApiPath.ByteDance:
|
||||
|
||||
@@ -52,6 +52,28 @@ export function auth(req: NextRequest, modelProvider: ModelProvider) {
|
||||
msg: "you are not allowed to access with your own api key",
|
||||
};
|
||||
}
|
||||
// Special handling for Bedrock
|
||||
if (modelProvider === ModelProvider.Bedrock) {
|
||||
const region = req.headers.get("X-Region");
|
||||
const accessKeyId = req.headers.get("X-Access-Key");
|
||||
const secretKey = req.headers.get("X-Secret-Key");
|
||||
|
||||
console.log("[Auth] Bedrock credentials:", {
|
||||
region,
|
||||
accessKeyId: accessKeyId ? "***" : undefined,
|
||||
secretKey: secretKey ? "***" : undefined,
|
||||
});
|
||||
|
||||
// Check if AWS credentials are provided
|
||||
if (!region || !accessKeyId || !secretKey) {
|
||||
return {
|
||||
error: true,
|
||||
msg: "Missing AWS credentials. Please configure Region, Access Key ID, and Secret Access Key in settings.",
|
||||
};
|
||||
}
|
||||
|
||||
return { error: false };
|
||||
}
|
||||
|
||||
// if user does not provide an api key, inject system api key
|
||||
if (!apiKey) {
|
||||
|
||||
288
app/api/bedrock.ts
Normal file
288
app/api/bedrock.ts
Normal file
@@ -0,0 +1,288 @@
|
||||
import { ModelProvider } from "../constant";
|
||||
import { prettyObject } from "../utils/format";
|
||||
import { NextRequest, NextResponse } from "next/server";
|
||||
import { auth } from "./auth";
|
||||
import {
|
||||
BedrockRuntimeClient,
|
||||
InvokeModelCommand,
|
||||
ValidationException,
|
||||
} from "@aws-sdk/client-bedrock-runtime";
|
||||
import { validateModelId } from "./bedrock/utils";
|
||||
import {
|
||||
ConverseRequest,
|
||||
formatRequestBody,
|
||||
parseModelResponse,
|
||||
} from "./bedrock/models";
|
||||
|
||||
interface ContentItem {
|
||||
type: string;
|
||||
text?: string;
|
||||
image_url?: {
|
||||
url: string;
|
||||
};
|
||||
}
|
||||
|
||||
const ALLOWED_PATH = new Set(["invoke", "converse"]);
|
||||
|
||||
export async function handle(
|
||||
req: NextRequest,
|
||||
{ params }: { params: { path: string[] } },
|
||||
) {
|
||||
console.log("[Bedrock Route] params ", params);
|
||||
|
||||
if (req.method === "OPTIONS") {
|
||||
return NextResponse.json({ body: "OK" }, { status: 200 });
|
||||
}
|
||||
|
||||
const subpath = params.path.join("/");
|
||||
|
||||
if (!ALLOWED_PATH.has(subpath)) {
|
||||
console.log("[Bedrock Route] forbidden path ", subpath);
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: true,
|
||||
msg: "you are not allowed to request " + subpath,
|
||||
},
|
||||
{
|
||||
status: 403,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const authResult = auth(req, ModelProvider.Bedrock);
|
||||
if (authResult.error) {
|
||||
return NextResponse.json(authResult, {
|
||||
status: 401,
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
if (subpath === "converse") {
|
||||
const response = await handleConverseRequest(req);
|
||||
return response;
|
||||
} else {
|
||||
const response = await handleInvokeRequest(req);
|
||||
return response;
|
||||
}
|
||||
} catch (e) {
|
||||
console.error("[Bedrock] ", e);
|
||||
|
||||
// Handle specific error cases
|
||||
if (e instanceof ValidationException) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: true,
|
||||
message:
|
||||
"Model validation error. If using a Llama model, please provide a valid inference profile ARN.",
|
||||
details: e.message,
|
||||
},
|
||||
{ status: 400 },
|
||||
);
|
||||
}
|
||||
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: true,
|
||||
message: e instanceof Error ? e.message : "Unknown error",
|
||||
details: prettyObject(e),
|
||||
},
|
||||
{ status: 500 },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
async function handleConverseRequest(req: NextRequest) {
|
||||
const controller = new AbortController();
|
||||
|
||||
const region = req.headers.get("X-Region") || "us-east-1";
|
||||
const accessKeyId = req.headers.get("X-Access-Key") || "";
|
||||
const secretAccessKey = req.headers.get("X-Secret-Key") || "";
|
||||
const sessionToken = req.headers.get("X-Session-Token");
|
||||
|
||||
if (!accessKeyId || !secretAccessKey) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: true,
|
||||
message: "Missing AWS credentials",
|
||||
},
|
||||
{
|
||||
status: 401,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
console.log("[Bedrock] Using region:", region);
|
||||
|
||||
const client = new BedrockRuntimeClient({
|
||||
region,
|
||||
credentials: {
|
||||
accessKeyId,
|
||||
secretAccessKey,
|
||||
sessionToken: sessionToken || undefined,
|
||||
},
|
||||
});
|
||||
|
||||
const timeoutId = setTimeout(
|
||||
() => {
|
||||
controller.abort();
|
||||
},
|
||||
10 * 60 * 1000,
|
||||
);
|
||||
|
||||
try {
|
||||
const body = (await req.json()) as ConverseRequest;
|
||||
const { modelId } = body;
|
||||
|
||||
// Validate model ID
|
||||
const validationError = validateModelId(modelId);
|
||||
if (validationError) {
|
||||
throw new ValidationException({
|
||||
message: validationError,
|
||||
$metadata: {},
|
||||
});
|
||||
}
|
||||
|
||||
console.log("[Bedrock] Invoking model:", modelId);
|
||||
console.log("[Bedrock] Messages:", body.messages);
|
||||
|
||||
const requestBody = formatRequestBody(body);
|
||||
|
||||
const jsonString = JSON.stringify(requestBody);
|
||||
const input = {
|
||||
modelId,
|
||||
contentType: "application/json",
|
||||
accept: "application/json",
|
||||
body: Uint8Array.from(Buffer.from(jsonString)),
|
||||
};
|
||||
|
||||
console.log("[Bedrock] Request input:", {
|
||||
...input,
|
||||
body: requestBody,
|
||||
});
|
||||
|
||||
const command = new InvokeModelCommand(input);
|
||||
const response = await client.send(command);
|
||||
|
||||
console.log("[Bedrock] Got response");
|
||||
|
||||
// Parse and format the response based on model type
|
||||
const responseBody = new TextDecoder().decode(response.body);
|
||||
const formattedResponse = parseModelResponse(responseBody, modelId);
|
||||
|
||||
return NextResponse.json(formattedResponse);
|
||||
} catch (e) {
|
||||
console.error("[Bedrock] Request error:", e);
|
||||
throw e; // Let the main error handler deal with it
|
||||
} finally {
|
||||
clearTimeout(timeoutId);
|
||||
}
|
||||
}
|
||||
|
||||
async function handleInvokeRequest(req: NextRequest) {
|
||||
const controller = new AbortController();
|
||||
|
||||
const region = req.headers.get("X-Region") || "us-east-1";
|
||||
const accessKeyId = req.headers.get("X-Access-Key") || "";
|
||||
const secretAccessKey = req.headers.get("X-Secret-Key") || "";
|
||||
const sessionToken = req.headers.get("X-Session-Token");
|
||||
|
||||
if (!accessKeyId || !secretAccessKey) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: true,
|
||||
message: "Missing AWS credentials",
|
||||
},
|
||||
{
|
||||
status: 401,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const client = new BedrockRuntimeClient({
|
||||
region,
|
||||
credentials: {
|
||||
accessKeyId,
|
||||
secretAccessKey,
|
||||
sessionToken: sessionToken || undefined,
|
||||
},
|
||||
});
|
||||
|
||||
const timeoutId = setTimeout(
|
||||
() => {
|
||||
controller.abort();
|
||||
},
|
||||
10 * 60 * 1000,
|
||||
);
|
||||
|
||||
try {
|
||||
const body = await req.json();
|
||||
const { messages, model } = body;
|
||||
|
||||
// Validate model ID
|
||||
const validationError = validateModelId(model);
|
||||
if (validationError) {
|
||||
throw new ValidationException({
|
||||
message: validationError,
|
||||
$metadata: {},
|
||||
});
|
||||
}
|
||||
|
||||
console.log("[Bedrock] Invoking model:", model);
|
||||
console.log("[Bedrock] Messages:", messages);
|
||||
|
||||
const requestBody = formatRequestBody({
|
||||
modelId: model,
|
||||
messages,
|
||||
inferenceConfig: {
|
||||
maxTokens: 2048,
|
||||
temperature: 0.7,
|
||||
topP: 0.9,
|
||||
},
|
||||
});
|
||||
|
||||
const jsonString = JSON.stringify(requestBody);
|
||||
const input = {
|
||||
modelId: model,
|
||||
contentType: "application/json",
|
||||
accept: "application/json",
|
||||
body: Uint8Array.from(Buffer.from(jsonString)),
|
||||
};
|
||||
|
||||
console.log("[Bedrock] Request input:", {
|
||||
...input,
|
||||
body: requestBody,
|
||||
});
|
||||
|
||||
const command = new InvokeModelCommand(input);
|
||||
const response = await client.send(command);
|
||||
|
||||
console.log("[Bedrock] Got response");
|
||||
|
||||
// Parse and format the response
|
||||
const responseBody = new TextDecoder().decode(response.body);
|
||||
const formattedResponse = parseModelResponse(responseBody, model);
|
||||
|
||||
// Extract text content from the response
|
||||
let textContent = "";
|
||||
if (formattedResponse.content && Array.isArray(formattedResponse.content)) {
|
||||
textContent = formattedResponse.content
|
||||
.filter((item: ContentItem) => item.type === "text")
|
||||
.map((item: ContentItem) => item.text || "")
|
||||
.join("");
|
||||
} else if (typeof formattedResponse.content === "string") {
|
||||
textContent = formattedResponse.content;
|
||||
}
|
||||
|
||||
// Return plain text response
|
||||
return new NextResponse(textContent, {
|
||||
headers: {
|
||||
"Content-Type": "text/plain",
|
||||
},
|
||||
});
|
||||
} catch (e) {
|
||||
console.error("[Bedrock] Request error:", e);
|
||||
throw e;
|
||||
} finally {
|
||||
clearTimeout(timeoutId);
|
||||
}
|
||||
}
|
||||
280
app/api/bedrock/models.ts
Normal file
280
app/api/bedrock/models.ts
Normal file
@@ -0,0 +1,280 @@
|
||||
import {
|
||||
Message,
|
||||
validateMessageOrder,
|
||||
processDocumentContent,
|
||||
BedrockTextBlock,
|
||||
BedrockImageBlock,
|
||||
BedrockDocumentBlock,
|
||||
} from "./utils";
|
||||
|
||||
export interface ConverseRequest {
|
||||
modelId: string;
|
||||
messages: Message[];
|
||||
inferenceConfig?: {
|
||||
maxTokens?: number;
|
||||
temperature?: number;
|
||||
topP?: number;
|
||||
};
|
||||
system?: string;
|
||||
tools?: Array<{
|
||||
type: "function";
|
||||
function: {
|
||||
name: string;
|
||||
description: string;
|
||||
parameters: {
|
||||
type: string;
|
||||
properties: Record<string, any>;
|
||||
required: string[];
|
||||
};
|
||||
};
|
||||
}>;
|
||||
}
|
||||
|
||||
interface ContentItem {
|
||||
type: string;
|
||||
text?: string;
|
||||
image_url?: {
|
||||
url: string;
|
||||
};
|
||||
document?: {
|
||||
format: string;
|
||||
name: string;
|
||||
source: {
|
||||
bytes: string;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
type ProcessedContent =
|
||||
| ContentItem
|
||||
| BedrockTextBlock
|
||||
| BedrockImageBlock
|
||||
| BedrockDocumentBlock
|
||||
| {
|
||||
type: string;
|
||||
source: { type: string; media_type: string; data: string };
|
||||
};
|
||||
|
||||
// Helper function to format request body based on model type
|
||||
export function formatRequestBody(request: ConverseRequest) {
|
||||
const baseModel = request.modelId;
|
||||
const messages = validateMessageOrder(request.messages).map((msg) => ({
|
||||
role: msg.role,
|
||||
content: Array.isArray(msg.content)
|
||||
? msg.content.map((item: ContentItem) => {
|
||||
if (item.type === "image_url" && item.image_url?.url) {
|
||||
// If it's a base64 image URL
|
||||
const base64Match = item.image_url.url.match(
|
||||
/^data:image\/([a-zA-Z]*);base64,([^"]*)$/,
|
||||
);
|
||||
if (base64Match) {
|
||||
return {
|
||||
type: "image",
|
||||
source: {
|
||||
type: "base64",
|
||||
media_type: `image/${base64Match[1]}`,
|
||||
data: base64Match[2],
|
||||
},
|
||||
};
|
||||
}
|
||||
// If it's not a base64 URL, return as is
|
||||
return item;
|
||||
}
|
||||
if ("document" in item) {
|
||||
try {
|
||||
return processDocumentContent(item);
|
||||
} catch (error) {
|
||||
console.error("Error processing document:", error);
|
||||
return {
|
||||
type: "text",
|
||||
text: `[Document: ${item.document?.name || "Unknown"}]`,
|
||||
};
|
||||
}
|
||||
}
|
||||
return { type: "text", text: item.text };
|
||||
})
|
||||
: [{ type: "text", text: msg.content }],
|
||||
}));
|
||||
|
||||
const systemPrompt = request.system
|
||||
? [{ type: "text", text: request.system }]
|
||||
: undefined;
|
||||
|
||||
const baseConfig = {
|
||||
max_tokens: request.inferenceConfig?.maxTokens || 2048,
|
||||
temperature: request.inferenceConfig?.temperature || 0.7,
|
||||
top_p: request.inferenceConfig?.topP || 0.9,
|
||||
};
|
||||
|
||||
if (baseModel.startsWith("anthropic.claude")) {
|
||||
return {
|
||||
messages,
|
||||
system: systemPrompt,
|
||||
anthropic_version: "bedrock-2023-05-31",
|
||||
...baseConfig,
|
||||
...(request.tools && { tools: request.tools }),
|
||||
};
|
||||
} else if (
|
||||
baseModel.startsWith("meta.llama") ||
|
||||
baseModel.startsWith("mistral.")
|
||||
) {
|
||||
return {
|
||||
messages: messages.map((m) => ({
|
||||
role: m.role,
|
||||
content: Array.isArray(m.content)
|
||||
? m.content.map((c: ProcessedContent) => {
|
||||
if ("text" in c) return { type: "text", text: c.text || "" };
|
||||
if ("image_url" in c)
|
||||
return {
|
||||
type: "text",
|
||||
text: `[Image: ${c.image_url?.url || "URL not provided"}]`,
|
||||
};
|
||||
if ("document" in c)
|
||||
return {
|
||||
type: "text",
|
||||
text: `[Document: ${c.document?.name || "Unknown"}]`,
|
||||
};
|
||||
return { type: "text", text: "" };
|
||||
})
|
||||
: [{ type: "text", text: m.content }],
|
||||
})),
|
||||
...baseConfig,
|
||||
stop_sequences: ["\n\nHuman:", "\n\nAssistant:"],
|
||||
};
|
||||
} else if (baseModel.startsWith("amazon.titan")) {
|
||||
const formattedText = messages.map((m) => ({
|
||||
role: m.role,
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `${m.role === "user" ? "Human" : "Assistant"}: ${
|
||||
Array.isArray(m.content)
|
||||
? m.content
|
||||
.map((c: ProcessedContent) => {
|
||||
if ("text" in c) return c.text || "";
|
||||
if ("image_url" in c)
|
||||
return `[Image: ${
|
||||
c.image_url?.url || "URL not provided"
|
||||
}]`;
|
||||
if ("document" in c)
|
||||
return `[Document: ${c.document?.name || "Unknown"}]`;
|
||||
return "";
|
||||
})
|
||||
.join("")
|
||||
: m.content
|
||||
}`,
|
||||
},
|
||||
],
|
||||
}));
|
||||
|
||||
return {
|
||||
messages: formattedText,
|
||||
textGenerationConfig: {
|
||||
maxTokenCount: baseConfig.max_tokens,
|
||||
temperature: baseConfig.temperature,
|
||||
topP: baseConfig.top_p,
|
||||
stopSequences: ["Human:", "Assistant:"],
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
throw new Error(`Unsupported model: ${baseModel}`);
|
||||
}
|
||||
|
||||
// Helper function to parse and format response based on model type
|
||||
export function parseModelResponse(responseBody: string, modelId: string): any {
|
||||
const baseModel = modelId;
|
||||
|
||||
try {
|
||||
const response = JSON.parse(responseBody);
|
||||
|
||||
// Common response format for all models
|
||||
const formatResponse = (content: string | any[]) => ({
|
||||
role: "assistant",
|
||||
content: Array.isArray(content)
|
||||
? content.map((item) => {
|
||||
if (typeof item === "string") {
|
||||
return { type: "text", text: item };
|
||||
}
|
||||
// Handle different content types
|
||||
if ("text" in item) {
|
||||
return { type: "text", text: item.text || "" };
|
||||
}
|
||||
if ("image" in item) {
|
||||
return {
|
||||
type: "image_url",
|
||||
image_url: {
|
||||
url: `data:image/${
|
||||
item.source?.media_type || "image/png"
|
||||
};base64,${item.source?.data || ""}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
// Document responses are converted to text
|
||||
if ("document" in item) {
|
||||
return {
|
||||
type: "text",
|
||||
text: `[Document Content]\n${item.text || ""}`,
|
||||
};
|
||||
}
|
||||
return { type: "text", text: item.text || "" };
|
||||
})
|
||||
: [{ type: "text", text: content }],
|
||||
stop_reason: response.stop_reason || response.stopReason || "end_turn",
|
||||
usage: response.usage || {
|
||||
input_tokens: 0,
|
||||
output_tokens: 0,
|
||||
total_tokens: 0,
|
||||
},
|
||||
});
|
||||
|
||||
if (baseModel.startsWith("anthropic.claude")) {
|
||||
// Handle the new Converse API response format
|
||||
if (response.output?.message) {
|
||||
return {
|
||||
role: response.output.message.role,
|
||||
content: response.output.message.content.map((item: any) => {
|
||||
if ("text" in item) return { type: "text", text: item.text || "" };
|
||||
if ("image" in item) {
|
||||
return {
|
||||
type: "image_url",
|
||||
image_url: {
|
||||
url: `data:${item.source?.media_type || "image/png"};base64,${
|
||||
item.source?.data || ""
|
||||
}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
return { type: "text", text: item.text || "" };
|
||||
}),
|
||||
stop_reason: response.stopReason,
|
||||
usage: response.usage,
|
||||
};
|
||||
}
|
||||
// Fallback for older format
|
||||
return formatResponse(
|
||||
response.content ||
|
||||
(response.completion
|
||||
? [{ type: "text", text: response.completion }]
|
||||
: []),
|
||||
);
|
||||
} else if (baseModel.startsWith("meta.llama")) {
|
||||
return formatResponse(response.generation || response.completion || "");
|
||||
} else if (baseModel.startsWith("amazon.titan")) {
|
||||
return formatResponse(response.results?.[0]?.outputText || "");
|
||||
} else if (baseModel.startsWith("mistral.")) {
|
||||
return formatResponse(
|
||||
response.outputs?.[0]?.text || response.response || "",
|
||||
);
|
||||
}
|
||||
|
||||
throw new Error(`Unsupported model: ${baseModel}`);
|
||||
} catch (e) {
|
||||
console.error("[Bedrock] Failed to parse response:", e);
|
||||
// Return raw text as fallback
|
||||
return {
|
||||
role: "assistant",
|
||||
content: [{ type: "text", text: responseBody }],
|
||||
};
|
||||
}
|
||||
}
|
||||
218
app/api/bedrock/utils.ts
Normal file
218
app/api/bedrock/utils.ts
Normal file
@@ -0,0 +1,218 @@
|
||||
import { MultimodalContent } from "../../client/api";
|
||||
|
||||
export interface Message {
|
||||
role: string;
|
||||
content: string | MultimodalContent[];
|
||||
}
|
||||
|
||||
export interface ImageSource {
|
||||
bytes: string; // base64 encoded image bytes
|
||||
}
|
||||
|
||||
export interface DocumentSource {
|
||||
bytes: string; // base64 encoded document bytes
|
||||
}
|
||||
|
||||
export interface BedrockImageBlock {
|
||||
image: {
|
||||
format: "png" | "jpeg" | "gif" | "webp";
|
||||
source: ImageSource;
|
||||
};
|
||||
}
|
||||
|
||||
export interface BedrockDocumentBlock {
|
||||
document: {
|
||||
format:
|
||||
| "pdf"
|
||||
| "csv"
|
||||
| "doc"
|
||||
| "docx"
|
||||
| "xls"
|
||||
| "xlsx"
|
||||
| "html"
|
||||
| "txt"
|
||||
| "md";
|
||||
name: string;
|
||||
source: DocumentSource;
|
||||
};
|
||||
}
|
||||
|
||||
export interface BedrockTextBlock {
|
||||
text: string;
|
||||
}
|
||||
|
||||
export type BedrockContentBlock =
|
||||
| BedrockTextBlock
|
||||
| BedrockImageBlock
|
||||
| BedrockDocumentBlock;
|
||||
|
||||
export interface BedrockResponse {
|
||||
content?: any[];
|
||||
completion?: string;
|
||||
stop_reason?: string;
|
||||
usage?: {
|
||||
input_tokens: number;
|
||||
output_tokens: number;
|
||||
total_tokens: number;
|
||||
};
|
||||
tool_calls?: any[];
|
||||
}
|
||||
|
||||
// Helper function to get the base model type from modelId
|
||||
export function getModelType(modelId: string): string {
|
||||
if (modelId.includes("inference-profile")) {
|
||||
const match = modelId.match(/us\.(meta\.llama.+?)$/);
|
||||
if (match) return match[1];
|
||||
}
|
||||
return modelId;
|
||||
}
|
||||
|
||||
// Helper function to validate model ID
|
||||
export function validateModelId(modelId: string): string | null {
|
||||
// Check if model requires inference profile
|
||||
if (
|
||||
modelId.startsWith("meta.llama") &&
|
||||
!modelId.includes("inference-profile")
|
||||
) {
|
||||
return "Llama models require an inference profile. Please use the full inference profile ARN.";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// Helper function to process document content for Bedrock
|
||||
export function processDocumentContent(content: any): BedrockContentBlock {
|
||||
if (
|
||||
!content?.document?.format ||
|
||||
!content?.document?.name ||
|
||||
!content?.document?.source?.bytes
|
||||
) {
|
||||
throw new Error("Invalid document content format");
|
||||
}
|
||||
|
||||
const format = content.document.format.toLowerCase();
|
||||
if (
|
||||
!["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"].includes(
|
||||
format,
|
||||
)
|
||||
) {
|
||||
throw new Error(`Unsupported document format: ${format}`);
|
||||
}
|
||||
|
||||
return {
|
||||
document: {
|
||||
format: format as BedrockDocumentBlock["document"]["format"],
|
||||
name: sanitizeDocumentName(content.document.name),
|
||||
source: {
|
||||
bytes: content.document.source.bytes,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// Helper function to format content for Bedrock
|
||||
export function formatContent(
|
||||
content: string | MultimodalContent[],
|
||||
): BedrockContentBlock[] {
|
||||
if (typeof content === "string") {
|
||||
return [{ text: content }];
|
||||
}
|
||||
|
||||
const formattedContent: BedrockContentBlock[] = [];
|
||||
|
||||
for (const item of content) {
|
||||
if (item.type === "text" && item.text) {
|
||||
formattedContent.push({ text: item.text });
|
||||
} else if (item.type === "image_url" && item.image_url?.url) {
|
||||
// Extract base64 data from data URL
|
||||
const base64Match = item.image_url.url.match(
|
||||
/^data:image\/([a-zA-Z]*);base64,([^"]*)$/,
|
||||
);
|
||||
if (base64Match) {
|
||||
const format = base64Match[1].toLowerCase();
|
||||
if (["png", "jpeg", "gif", "webp"].includes(format)) {
|
||||
formattedContent.push({
|
||||
image: {
|
||||
format: format as "png" | "jpeg" | "gif" | "webp",
|
||||
source: {
|
||||
bytes: base64Match[2],
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if ("document" in item) {
|
||||
try {
|
||||
formattedContent.push(processDocumentContent(item));
|
||||
} catch (error) {
|
||||
console.error("Error processing document:", error);
|
||||
// Convert document to text as fallback
|
||||
formattedContent.push({
|
||||
text: `[Document: ${(item as any).document?.name || "Unknown"}]`,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return formattedContent;
|
||||
}
|
||||
|
||||
// Helper function to ensure messages alternate between user and assistant
|
||||
export function validateMessageOrder(messages: Message[]): Message[] {
|
||||
const validatedMessages: Message[] = [];
|
||||
let lastRole = "";
|
||||
|
||||
for (const message of messages) {
|
||||
if (message.role === lastRole) {
|
||||
// Skip duplicate roles to maintain alternation
|
||||
continue;
|
||||
}
|
||||
validatedMessages.push(message);
|
||||
lastRole = message.role;
|
||||
}
|
||||
|
||||
return validatedMessages;
|
||||
}
|
||||
|
||||
// Helper function to sanitize document names according to Bedrock requirements
|
||||
function sanitizeDocumentName(name: string): string {
|
||||
// Remove any characters that aren't alphanumeric, whitespace, hyphens, or parentheses
|
||||
let sanitized = name.replace(/[^a-zA-Z0-9\s\-\(\)\[\]]/g, "");
|
||||
// Replace multiple whitespace characters with a single space
|
||||
sanitized = sanitized.replace(/\s+/g, " ");
|
||||
// Trim whitespace from start and end
|
||||
return sanitized.trim();
|
||||
}
|
||||
|
||||
// Helper function to convert Bedrock response back to MultimodalContent format
|
||||
export function convertBedrockResponseToMultimodal(
|
||||
response: BedrockResponse,
|
||||
): string | MultimodalContent[] {
|
||||
if (response.completion) {
|
||||
return response.completion;
|
||||
}
|
||||
|
||||
if (!response.content) {
|
||||
return "";
|
||||
}
|
||||
|
||||
return response.content.map((block) => {
|
||||
if ("text" in block) {
|
||||
return {
|
||||
type: "text",
|
||||
text: block.text,
|
||||
};
|
||||
} else if ("image" in block) {
|
||||
return {
|
||||
type: "image_url",
|
||||
image_url: {
|
||||
url: `data:image/${block.image.format};base64,${block.image.source.bytes}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
// Document responses are converted to text content
|
||||
return {
|
||||
type: "text",
|
||||
text: block.text || "",
|
||||
};
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user