修改： .env.template

修改： app/api/auth.ts 修改： app/api/bedrock.ts 修改： app/client/api.ts 修改： app/client/platforms/bedrock.ts 修改： app/components/settings.tsx 修改： app/config/server.ts 修改： app/constant.t
修改： app/client/platforms/bedrock.ts
2026-03-09 21:54:24 +08:00 · 2024-11-05 14:27:52 +08:00 · 2024-11-05 10:34:33 +08:00 · 2024-11-04 16:24:10 +08:00 · 2024-10-31 14:23:38 +08:00 · 2024-10-31 11:51:41 +08:00
26 changed files with 1150 additions and 504 deletions
--- a/.env.template
+++ b/.env.template
@@ -66,4 +66,9 @@ ANTHROPIC_API_VERSION=
 ANTHROPIC_URL=

 ### (optional)
-WHITE_WEBDAV_ENDPOINTS=
+WHITE_WEBDAV_ENDPOINTS=
+
+### bedrock  (optional)
+AWS_REGION=
+AWS_ACCESS_KEY=
+AWS_SECRET_KEY=
--- a/README.md
+++ b/README.md
@@ -397,9 +397,6 @@ yarn dev

 > [简体中文 > 如何部署到私人服务器](./README_CN.md#部署)

-### BT Install
-> [简体中文 > 如何通过宝塔一键部署](./docs/bt-cn.md)
-
 ### Docker (Recommended)

 ```shell
--- a/README_CN.md
+++ b/README_CN.md
@@ -264,9 +264,6 @@ BASE_URL=https://b.nextweb.fun/api/proxy

 ## 部署

-### 宝塔面板部署
-> [简体中文 > 如何通过宝塔一键部署](./docs/bt-cn.md)
-
 ### 容器部署 （推荐）

 > Docker 版本需要在 20 及其以上，否则会提示找不到镜像。
--- a/app/api/[provider]/[...path]/route.ts
+++ b/app/api/[provider]/[...path]/route.ts
@@ -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";
@@ -11,7 +12,6 @@ import { handle as moonshotHandler } from "../../moonshot";
 import { handle as stabilityHandler } from "../../stability";
 import { handle as iflytekHandler } from "../../iflytek";
 import { handle as xaiHandler } from "../../xai";
-import { handle as chatglmHandler } from "../../glm";
 import { handle as proxyHandler } from "../../proxy";

 async function handle(
@@ -21,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:
@@ -42,8 +45,6 @@ async function handle(
      return iflytekHandler(req, { params });
    case ApiPath.XAI:
      return xaiHandler(req, { params });
-    case ApiPath.ChatGLM:
-      return chatglmHandler(req, { params });
    case ApiPath.OpenAI:
      return openaiHandler(req, { params });
    default:
--- a/app/api/auth.ts
+++ b/app/api/auth.ts
@@ -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 = serverConfig.awsRegion;
+    const accessKeyId = serverConfig.awsAccessKey;
+    const secretAccessKey = serverConfig.awsSecretKey;
+
+    console.log("[Auth] Bedrock credentials:", {
+      region,
+      accessKeyId: accessKeyId ? "***" : undefined,
+      secretKey: secretAccessKey ? "***" : undefined,
+    });
+
+    // Check if AWS credentials are provided
+    if (!region || !accessKeyId || !secretAccessKey) {
+      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) {
@@ -95,9 +117,6 @@ export function auth(req: NextRequest, modelProvider: ModelProvider) {
      case ModelProvider.XAI:
        systemApiKey = serverConfig.xaiApiKey;
        break;
-      case ModelProvider.ChatGLM:
-        systemApiKey = serverConfig.chatglmApiKey;
-        break;
      case ModelProvider.GPT:
      default:
        if (req.nextUrl.pathname.includes("azure/deployments")) {
--- a/app/api/bedrock.ts
+++ b/app/api/bedrock.ts
@@ -0,0 +1,562 @@
+import { getServerSideConfig } from "../config/server";
+import { prettyObject } from "../utils/format";
+import { NextRequest, NextResponse } from "next/server";
+import {
+  BedrockRuntimeClient,
+  ConverseStreamCommand,
+  ConverseStreamCommandInput,
+  ConverseStreamOutput,
+  ModelStreamErrorException,
+  type Message,
+  type ContentBlock,
+  type SystemContentBlock,
+  type Tool,
+  type ToolChoice,
+  type ToolResultContentBlock,
+} from "@aws-sdk/client-bedrock-runtime";
+
+// 解密函数
+function decrypt(str: string): string {
+  try {
+    return Buffer.from(str, "base64").toString().split("").reverse().join("");
+  } catch {
+    return "";
+  }
+}
+
+// Constants and Types
+const ALLOWED_PATH = new Set(["converse"]);
+
+export interface ConverseRequest {
+  modelId: string;
+  messages: {
+    role: "user" | "assistant" | "system";
+    content: string | ContentItem[];
+  }[];
+  inferenceConfig?: {
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+  };
+  toolConfig?: {
+    tools: Tool[];
+    toolChoice?: ToolChoice;
+  };
+}
+
+interface ContentItem {
+  type: "text" | "image_url" | "document" | "tool_use" | "tool_result";
+  text?: string;
+  image_url?: {
+    url: string; // base64 data URL
+  };
+  document?: {
+    format: DocumentFormat;
+    name: string;
+    source: {
+      bytes: string; // base64
+    };
+  };
+  tool_use?: {
+    tool_use_id: string;
+    name: string;
+    input: any;
+  };
+  tool_result?: {
+    tool_use_id: string;
+    content: ToolResultItem[];
+    status: "success" | "error";
+  };
+}
+
+interface ToolResultItem {
+  type: "text" | "image" | "document" | "json";
+  text?: string;
+  image?: {
+    format: "png" | "jpeg" | "gif" | "webp";
+    source: {
+      bytes: string; // base64
+    };
+  };
+  document?: {
+    format: DocumentFormat;
+    name: string;
+    source: {
+      bytes: string; // base64
+    };
+  };
+  json?: any;
+}
+
+type DocumentFormat =
+  | "pdf"
+  | "csv"
+  | "doc"
+  | "docx"
+  | "xls"
+  | "xlsx"
+  | "html"
+  | "txt"
+  | "md";
+
+function validateImageSize(base64Data: string): boolean {
+  const sizeInBytes = (base64Data.length * 3) / 4;
+  const maxSize = 3.75 * 1024 * 1024;
+  if (sizeInBytes > maxSize) {
+    throw new Error("Image size exceeds 3.75 MB limit");
+  }
+  return true;
+}
+
+// Content Processing Functions
+function convertContentToAWSBlock(item: ContentItem): ContentBlock | null {
+  if (item.type === "text" && item.text) {
+    return { text: item.text };
+  }
+
+  if (item.type === "image_url" && item.image_url?.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)) {
+        validateImageSize(base64Match[2]);
+        return {
+          image: {
+            format: format as "png" | "jpeg" | "gif" | "webp",
+            source: {
+              bytes: Uint8Array.from(Buffer.from(base64Match[2], "base64")),
+            },
+          },
+        };
+      }
+    }
+  }
+
+  if (item.type === "tool_use" && item.tool_use) {
+    return {
+      toolUse: {
+        toolUseId: item.tool_use.tool_use_id,
+        name: item.tool_use.name,
+        input: item.tool_use.input,
+      },
+    };
+  }
+
+  if (item.type === "tool_result" && item.tool_result) {
+    const toolResultContent = item.tool_result.content
+      .map((resultItem) => {
+        if (resultItem.type === "text" && resultItem.text) {
+          return { text: resultItem.text } as ToolResultContentBlock;
+        }
+        if (resultItem.type === "image" && resultItem.image) {
+          return {
+            image: {
+              format: resultItem.image.format,
+              source: {
+                bytes: Uint8Array.from(
+                  Buffer.from(resultItem.image.source.bytes, "base64"),
+                ),
+              },
+            },
+          } as ToolResultContentBlock;
+        }
+        if (resultItem.type === "document" && resultItem.document) {
+          return {
+            document: {
+              format: resultItem.document.format,
+              name: resultItem.document.name,
+              source: {
+                bytes: Uint8Array.from(
+                  Buffer.from(resultItem.document.source.bytes, "base64"),
+                ),
+              },
+            },
+          } as ToolResultContentBlock;
+        }
+        if (resultItem.type === "json" && resultItem.json) {
+          return { json: resultItem.json } as ToolResultContentBlock;
+        }
+        return null;
+      })
+      .filter((content): content is ToolResultContentBlock => content !== null);
+
+    if (toolResultContent.length === 0) {
+      return null;
+    }
+
+    return {
+      toolResult: {
+        toolUseId: item.tool_result.tool_use_id,
+        content: toolResultContent,
+        status: item.tool_result.status,
+      },
+    };
+  }
+
+  return null;
+}
+
+function convertContentToAWS(content: string | ContentItem[]): ContentBlock[] {
+  if (typeof content === "string") {
+    return [{ text: content }];
+  }
+
+  const blocks = content
+    .map(convertContentToAWSBlock)
+    .filter((block): block is ContentBlock => block !== null);
+
+  return blocks.length > 0 ? blocks : [{ text: "" }];
+}
+
+function formatMessages(messages: ConverseRequest["messages"]): {
+  messages: Message[];
+  systemPrompt?: SystemContentBlock[];
+} {
+  const systemMessages = messages.filter((msg) => msg.role === "system");
+  const nonSystemMessages = messages.filter((msg) => msg.role !== "system");
+
+  const systemPrompt =
+    systemMessages.length > 0
+      ? systemMessages.map((msg) => {
+          if (typeof msg.content === "string") {
+            return { text: msg.content } as SystemContentBlock;
+          }
+          const blocks = convertContentToAWS(msg.content);
+          return blocks[0] as SystemContentBlock;
+        })
+      : undefined;
+
+  const formattedMessages = nonSystemMessages.reduce(
+    (acc: Message[], curr, idx) => {
+      if (idx > 0 && curr.role === nonSystemMessages[idx - 1].role) {
+        return acc;
+      }
+
+      const content = convertContentToAWS(curr.content);
+      if (content.length > 0) {
+        acc.push({
+          role: curr.role as "user" | "assistant",
+          content,
+        });
+      }
+      return acc;
+    },
+    [],
+  );
+
+  if (formattedMessages.length === 0 || formattedMessages[0].role !== "user") {
+    formattedMessages.unshift({
+      role: "user",
+      content: [{ text: "Hello" }],
+    });
+  }
+
+  if (formattedMessages[formattedMessages.length - 1].role !== "user") {
+    formattedMessages.push({
+      role: "user",
+      content: [{ text: "Continue" }],
+    });
+  }
+
+  return { messages: formattedMessages, systemPrompt };
+}
+
+function formatRequestBody(
+  request: ConverseRequest,
+): ConverseStreamCommandInput {
+  const { messages, systemPrompt } = formatMessages(request.messages);
+  const input: ConverseStreamCommandInput = {
+    modelId: request.modelId,
+    messages,
+    ...(systemPrompt && { system: systemPrompt }),
+  };
+
+  if (request.inferenceConfig) {
+    input.inferenceConfig = {
+      maxTokens: request.inferenceConfig.maxTokens,
+      temperature: request.inferenceConfig.temperature,
+      topP: request.inferenceConfig.topP,
+      stopSequences: request.inferenceConfig.stopSequences,
+    };
+  }
+
+  if (request.toolConfig) {
+    input.toolConfig = {
+      tools: request.toolConfig.tools,
+      toolChoice: request.toolConfig.toolChoice,
+    };
+  }
+
+  const logInput = {
+    ...input,
+    messages: messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content?.map((content) => {
+        if ("image" in content && content.image) {
+          return {
+            image: {
+              format: content.image.format,
+              source: { bytes: "[BINARY]" },
+            },
+          };
+        }
+        if ("document" in content && content.document) {
+          return {
+            document: { ...content.document, source: { bytes: "[BINARY]" } },
+          };
+        }
+        return content;
+      }),
+    })),
+  };
+
+  console.log(
+    "[Bedrock] Formatted request:",
+    JSON.stringify(logInput, null, 2),
+  );
+  return input;
+}
+
+// Main Request Handler
+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 serverConfig = getServerSideConfig();
+
+  // 首先尝试使用环境变量中的凭证
+  let region = serverConfig.awsRegion;
+  let accessKeyId = serverConfig.awsAccessKey;
+  let secretAccessKey = serverConfig.awsSecretKey;
+  let sessionToken = undefined;
+
+  // 如果环境变量中没有配置，则尝试使用前端传来的加密凭证
+  if (!region || !accessKeyId || !secretAccessKey) {
+    // 解密前端传来的凭证
+    region = decrypt(req.headers.get("X-Region") ?? "");
+    accessKeyId = decrypt(req.headers.get("X-Access-Key") ?? "");
+    secretAccessKey = decrypt(req.headers.get("X-Secret-Key") ?? "");
+    sessionToken = req.headers.get("X-Session-Token")
+      ? decrypt(req.headers.get("X-Session-Token") ?? "")
+      : undefined;
+  }
+
+  if (!region || !accessKeyId || !secretAccessKey) {
+    return NextResponse.json(
+      {
+        error: true,
+        msg: "AWS credentials not found in environment variables or request headers",
+      },
+      {
+        status: 401,
+      },
+    );
+  }
+
+  try {
+    const client = new BedrockRuntimeClient({
+      region,
+      credentials: {
+        accessKeyId,
+        secretAccessKey,
+        sessionToken,
+      },
+    });
+
+    const response = await handleConverseRequest(req, client);
+    return response;
+  } catch (e) {
+    console.error("[Bedrock] ", e);
+    return NextResponse.json(
+      {
+        error: true,
+        message: e instanceof Error ? e.message : "Unknown error",
+        details: prettyObject(e),
+      },
+      { status: 500 },
+    );
+  }
+}
+
+async function handleConverseRequest(
+  req: NextRequest,
+  client: BedrockRuntimeClient,
+) {
+  try {
+    const body = (await req.json()) as ConverseRequest;
+    const { modelId } = body;
+
+    console.log("[Bedrock] Invoking model:", modelId);
+
+    const command = new ConverseStreamCommand(formatRequestBody(body));
+    const response = await client.send(command);
+
+    if (!response.stream) {
+      throw new Error("No stream in response");
+    }
+
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          const responseStream = response.stream;
+          if (!responseStream) {
+            throw new Error("No stream in response");
+          }
+
+          for await (const event of responseStream) {
+            const output = event as ConverseStreamOutput;
+
+            if ("messageStart" in output && output.messageStart?.role) {
+              controller.enqueue(
+                `data: ${JSON.stringify({
+                  stream: {
+                    messageStart: { role: output.messageStart.role },
+                  },
+                })}\n\n`,
+              );
+            } else if (
+              "contentBlockStart" in output &&
+              output.contentBlockStart
+            ) {
+              controller.enqueue(
+                `data: ${JSON.stringify({
+                  stream: {
+                    contentBlockStart: {
+                      contentBlockIndex:
+                        output.contentBlockStart.contentBlockIndex,
+                      start: output.contentBlockStart.start,
+                    },
+                  },
+                })}\n\n`,
+              );
+            } else if (
+              "contentBlockDelta" in output &&
+              output.contentBlockDelta?.delta
+            ) {
+              if ("text" in output.contentBlockDelta.delta) {
+                controller.enqueue(
+                  `data: ${JSON.stringify({
+                    stream: {
+                      contentBlockDelta: {
+                        delta: { text: output.contentBlockDelta.delta.text },
+                        contentBlockIndex:
+                          output.contentBlockDelta.contentBlockIndex,
+                      },
+                    },
+                  })}\n\n`,
+                );
+              } else if ("toolUse" in output.contentBlockDelta.delta) {
+                controller.enqueue(
+                  `data: ${JSON.stringify({
+                    stream: {
+                      contentBlockDelta: {
+                        delta: {
+                          toolUse: {
+                            input:
+                              output.contentBlockDelta.delta.toolUse?.input,
+                          },
+                        },
+                        contentBlockIndex:
+                          output.contentBlockDelta.contentBlockIndex,
+                      },
+                    },
+                  })}\n\n`,
+                );
+              }
+            } else if (
+              "contentBlockStop" in output &&
+              output.contentBlockStop
+            ) {
+              controller.enqueue(
+                `data: ${JSON.stringify({
+                  stream: {
+                    contentBlockStop: {
+                      contentBlockIndex:
+                        output.contentBlockStop.contentBlockIndex,
+                    },
+                  },
+                })}\n\n`,
+              );
+            } else if ("messageStop" in output && output.messageStop) {
+              controller.enqueue(
+                `data: ${JSON.stringify({
+                  stream: {
+                    messageStop: {
+                      stopReason: output.messageStop.stopReason,
+                      additionalModelResponseFields:
+                        output.messageStop.additionalModelResponseFields,
+                    },
+                  },
+                })}\n\n`,
+              );
+            } else if ("metadata" in output && output.metadata) {
+              controller.enqueue(
+                `data: ${JSON.stringify({
+                  stream: {
+                    metadata: {
+                      usage: output.metadata.usage,
+                      metrics: output.metadata.metrics,
+                      trace: output.metadata.trace,
+                    },
+                  },
+                })}\n\n`,
+              );
+            }
+          }
+          controller.close();
+        } catch (error) {
+          const errorResponse = {
+            stream: {
+              error:
+                error instanceof Error
+                  ? error.constructor.name
+                  : "UnknownError",
+              message: error instanceof Error ? error.message : "Unknown error",
+              ...(error instanceof ModelStreamErrorException && {
+                originalStatusCode: error.originalStatusCode,
+                originalMessage: error.originalMessage,
+              }),
+            },
+          };
+          controller.enqueue(`data: ${JSON.stringify(errorResponse)}\n\n`);
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("[Bedrock] Request error:", error);
+    throw error;
+  }
+}
--- a/app/api/glm.ts
+++ b/app/api/glm.ts
@@ -1,129 +0,0 @@
-import { getServerSideConfig } from "@/app/config/server";
-import {
-  CHATGLM_BASE_URL,
-  ApiPath,
-  ModelProvider,
-  ServiceProvider,
-} from "@/app/constant";
-import { prettyObject } from "@/app/utils/format";
-import { NextRequest, NextResponse } from "next/server";
-import { auth } from "@/app/api/auth";
-import { isModelAvailableInServer } from "@/app/utils/model";
-
-const serverConfig = getServerSideConfig();
-
-export async function handle(
-  req: NextRequest,
-  { params }: { params: { path: string[] } },
-) {
-  console.log("[GLM Route] params ", params);
-
-  if (req.method === "OPTIONS") {
-    return NextResponse.json({ body: "OK" }, { status: 200 });
-  }
-
-  const authResult = auth(req, ModelProvider.ChatGLM);
-  if (authResult.error) {
-    return NextResponse.json(authResult, {
-      status: 401,
-    });
-  }
-
-  try {
-    const response = await request(req);
-    return response;
-  } catch (e) {
-    console.error("[GLM] ", e);
-    return NextResponse.json(prettyObject(e));
-  }
-}
-
-async function request(req: NextRequest) {
-  const controller = new AbortController();
-
-  // alibaba use base url or just remove the path
-  let path = `${req.nextUrl.pathname}`.replaceAll(ApiPath.ChatGLM, "");
-
-  let baseUrl = serverConfig.chatglmUrl || CHATGLM_BASE_URL;
-
-  if (!baseUrl.startsWith("http")) {
-    baseUrl = `https://${baseUrl}`;
-  }
-
-  if (baseUrl.endsWith("/")) {
-    baseUrl = baseUrl.slice(0, -1);
-  }
-
-  console.log("[Proxy] ", path);
-  console.log("[Base Url]", baseUrl);
-
-  const timeoutId = setTimeout(
-    () => {
-      controller.abort();
-    },
-    10 * 60 * 1000,
-  );
-
-  const fetchUrl = `${baseUrl}${path}`;
-  console.log("[Fetch Url] ", fetchUrl);
-  const fetchOptions: RequestInit = {
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: req.headers.get("Authorization") ?? "",
-    },
-    method: req.method,
-    body: req.body,
-    redirect: "manual",
-    // @ts-ignore
-    duplex: "half",
-    signal: controller.signal,
-  };
-
-  // #1815 try to refuse some request to some models
-  if (serverConfig.customModels && req.body) {
-    try {
-      const clonedBody = await req.text();
-      fetchOptions.body = clonedBody;
-
-      const jsonBody = JSON.parse(clonedBody) as { model?: string };
-
-      // not undefined and is false
-      if (
-        isModelAvailableInServer(
-          serverConfig.customModels,
-          jsonBody?.model as string,
-          ServiceProvider.ChatGLM as string,
-        )
-      ) {
-        return NextResponse.json(
-          {
-            error: true,
-            message: `you are not allowed to use ${jsonBody?.model} model`,
-          },
-          {
-            status: 403,
-          },
-        );
-      }
-    } catch (e) {
-      console.error(`[GLM] filter`, e);
-    }
-  }
-  try {
-    const res = await fetch(fetchUrl, fetchOptions);
-
-    // to prevent browser prompt for credentials
-    const newHeaders = new Headers(res.headers);
-    newHeaders.delete("www-authenticate");
-    // to disable nginx buffering
-    newHeaders.set("X-Accel-Buffering", "no");
-
-    return new Response(res.body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers: newHeaders,
-    });
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
--- a/app/client/api.ts
+++ b/app/client/api.ts
@@ -12,6 +12,7 @@ import {
  useChatStore,
 } from "../store";
 import { ChatGPTApi, DalleRequestPayload } from "./platforms/openai";
+import { BedrockApi } from "./platforms/bedrock";
 import { GeminiProApi } from "./platforms/google";
 import { ClaudeApi } from "./platforms/anthropic";
 import { ErnieApi } from "./platforms/baidu";
@@ -21,7 +22,6 @@ import { HunyuanApi } from "./platforms/tencent";
 import { MoonshotApi } from "./platforms/moonshot";
 import { SparkApi } from "./platforms/iflytek";
 import { XAIApi } from "./platforms/xai";
-import { ChatGLMApi } from "./platforms/glm";

 export const ROLES = ["system", "user", "assistant"] as const;
 export type MessageRole = (typeof ROLES)[number];
@@ -31,11 +31,19 @@ export const TTSModels = ["tts-1", "tts-1-hd"] as const;
 export type ChatModel = ModelType;

 export interface MultimodalContent {
-  type: "text" | "image_url";
+  type: "text" | "image_url" | "document";
  text?: string;
  image_url?: {
    url: string;
  };
+  document?: {
+    format: string;
+    name: string;
+    source: {
+      bytes: string;
+      media_type?: string;
+    };
+  };
 }

 export interface RequestMessage {
@@ -130,6 +138,9 @@ export class ClientApi {

  constructor(provider: ModelProvider = ModelProvider.GPT) {
    switch (provider) {
+      case ModelProvider.Bedrock:
+        this.llm = new BedrockApi();
+        break;
      case ModelProvider.GeminiPro:
        this.llm = new GeminiProApi();
        break;
@@ -157,9 +168,6 @@ export class ClientApi {
      case ModelProvider.XAI:
        this.llm = new XAIApi();
        break;
-      case ModelProvider.ChatGLM:
-        this.llm = new ChatGLMApi();
-        break;
      default:
        this.llm = new ChatGPTApi();
    }
@@ -239,6 +247,7 @@ export function getHeaders(ignoreHeaders: boolean = false) {

  function getConfig() {
    const modelConfig = chatStore.currentSession().mask.modelConfig;
+    const isBedrock = modelConfig.providerName === ServiceProvider.Bedrock;
    const isGoogle = modelConfig.providerName === ServiceProvider.Google;
    const isAzure = modelConfig.providerName === ServiceProvider.Azure;
    const isAnthropic = modelConfig.providerName === ServiceProvider.Anthropic;
@@ -248,10 +257,11 @@ export function getHeaders(ignoreHeaders: boolean = false) {
    const isMoonshot = modelConfig.providerName === ServiceProvider.Moonshot;
    const isIflytek = modelConfig.providerName === ServiceProvider.Iflytek;
    const isXAI = modelConfig.providerName === ServiceProvider.XAI;
-    const isChatGLM = modelConfig.providerName === ServiceProvider.ChatGLM;
    const isEnabledAccessControl = accessStore.enabledAccessControl();
    const apiKey = isGoogle
      ? accessStore.googleApiKey
+      : isBedrock
+      ? accessStore.awsAccessKey // Use AWS access key for Bedrock
      : isAzure
      ? accessStore.azureApiKey
      : isAnthropic
@@ -264,14 +274,13 @@ export function getHeaders(ignoreHeaders: boolean = false) {
      ? accessStore.moonshotApiKey
      : isXAI
      ? accessStore.xaiApiKey
-      : isChatGLM
-      ? accessStore.chatglmApiKey
      : isIflytek
      ? accessStore.iflytekApiKey && accessStore.iflytekApiSecret
        ? accessStore.iflytekApiKey + ":" + accessStore.iflytekApiSecret
        : ""
      : accessStore.openaiApiKey;
    return {
+      isBedrock,
      isGoogle,
      isAzure,
      isAnthropic,
@@ -281,7 +290,6 @@ export function getHeaders(ignoreHeaders: boolean = false) {
      isMoonshot,
      isIflytek,
      isXAI,
-      isChatGLM,
      apiKey,
      isEnabledAccessControl,
    };
@@ -294,10 +302,13 @@ export function getHeaders(ignoreHeaders: boolean = false) {
      ? "x-api-key"
      : isGoogle
      ? "x-goog-api-key"
+      : isBedrock
+      ? "x-api-key"
      : "Authorization";
  }

  const {
+    isBedrock,
    isGoogle,
    isAzure,
    isAnthropic,
@@ -310,17 +321,30 @@ export function getHeaders(ignoreHeaders: boolean = false) {

  const authHeader = getAuthHeader();

-  const bearerToken = getBearerToken(
-    apiKey,
-    isAzure || isAnthropic || isGoogle,
-  );
+  if (isBedrock) {
+    // 简单加密 AWS credentials
+    const encrypt = (str: string) =>
+      Buffer.from(str.split("").reverse().join("")).toString("base64");

-  if (bearerToken) {
-    headers[authHeader] = bearerToken;
-  } else if (isEnabledAccessControl && validString(accessStore.accessCode)) {
-    headers["Authorization"] = getBearerToken(
-      ACCESS_CODE_PREFIX + accessStore.accessCode,
+    headers["X-Region"] = encrypt(accessStore.awsRegion);
+    headers["X-Access-Key"] = encrypt(accessStore.awsAccessKey);
+    headers["X-Secret-Key"] = encrypt(accessStore.awsSecretKey);
+    if (accessStore.awsSessionToken) {
+      headers["X-Session-Token"] = encrypt(accessStore.awsSessionToken);
+    }
+  } else {
+    const bearerToken = getBearerToken(
+      apiKey,
+      isAzure || isAnthropic || isGoogle,
    );
+
+    if (bearerToken) {
+      headers[authHeader] = bearerToken;
+    } else if (isEnabledAccessControl && validString(accessStore.accessCode)) {
+      headers["Authorization"] = getBearerToken(
+        ACCESS_CODE_PREFIX + accessStore.accessCode,
+      );
+    }
  }

  return headers;
@@ -328,6 +352,8 @@ export function getHeaders(ignoreHeaders: boolean = false) {

 export function getClientApi(provider: ServiceProvider): ClientApi {
  switch (provider) {
+    case ServiceProvider.Bedrock:
+      return new ClientApi(ModelProvider.Bedrock);
    case ServiceProvider.Google:
      return new ClientApi(ModelProvider.GeminiPro);
    case ServiceProvider.Anthropic:
@@ -346,8 +372,6 @@ export function getClientApi(provider: ServiceProvider): ClientApi {
      return new ClientApi(ModelProvider.Iflytek);
    case ServiceProvider.XAI:
      return new ClientApi(ModelProvider.XAI);
-    case ServiceProvider.ChatGLM:
-      return new ClientApi(ModelProvider.ChatGLM);
    default:
      return new ClientApi(ModelProvider.GPT);
  }
--- a/app/client/platforms/bedrock.ts
+++ b/app/client/platforms/bedrock.ts
@@ -0,0 +1,317 @@
+import { ApiPath } from "../../constant";
+import {
+  ChatOptions,
+  getHeaders,
+  LLMApi,
+  LLMModel,
+  LLMUsage,
+  SpeechOptions,
+} from "../api";
+import {
+  useAppConfig,
+  usePluginStore,
+  useChatStore,
+  ChatMessageTool,
+} from "../../store";
+import { getMessageTextContent, isVisionModel } from "../../utils";
+import { fetch } from "../../utils/stream";
+import { preProcessImageContent, stream } from "../../utils/chat";
+
+export type MultiBlockContent = {
+  type: "image" | "text";
+  source?: {
+    type: string;
+    media_type: string;
+    data: string;
+  };
+  text?: string;
+};
+
+export type AnthropicMessage = {
+  role: (typeof ClaudeMapper)[keyof typeof ClaudeMapper];
+  content: string | MultiBlockContent[];
+};
+
+const ClaudeMapper = {
+  assistant: "assistant",
+  user: "user",
+  system: "user",
+} as const;
+
+export class BedrockApi implements LLMApi {
+  usage(): Promise<LLMUsage> {
+    throw new Error("Method not implemented.");
+  }
+  models(): Promise<LLMModel[]> {
+    throw new Error("Method not implemented.");
+  }
+  speech(options: SpeechOptions): Promise<ArrayBuffer> {
+    throw new Error("Speech not implemented for Bedrock.");
+  }
+
+  extractMessage(res: any) {
+    console.log("[Response] bedrock response: ", res);
+    if (Array.isArray(res?.content)) {
+      return res.content;
+    }
+    return res;
+  }
+
+  async chat(options: ChatOptions): Promise<void> {
+    const visionModel = isVisionModel(options.config.model);
+    const shouldStream = !!options.config.stream;
+    const modelConfig = {
+      ...useAppConfig.getState().modelConfig,
+      ...useChatStore.getState().currentSession().mask.modelConfig,
+      ...{
+        model: options.config.model,
+      },
+    };
+
+    // try get base64image from local cache image_url
+    const messages: ChatOptions["messages"] = [];
+    for (const v of options.messages) {
+      const content = await preProcessImageContent(v.content);
+      messages.push({ role: v.role, content });
+    }
+
+    const keys = ["system", "user"];
+
+    // roles must alternate between "user" and "assistant" in claude, so add a fake assistant message between two user messages
+    for (let i = 0; i < messages.length - 1; i++) {
+      const message = messages[i];
+      const nextMessage = messages[i + 1];
+
+      if (keys.includes(message.role) && keys.includes(nextMessage.role)) {
+        messages[i] = [
+          message,
+          {
+            role: "assistant",
+            content: ";",
+          },
+        ] as any;
+      }
+    }
+
+    const prompt = messages
+      .flat()
+      .filter((v) => {
+        if (!v.content) return false;
+        if (typeof v.content === "string" && !v.content.trim()) return false;
+        return true;
+      })
+      .map((v) => {
+        const { role, content } = v;
+        const insideRole = ClaudeMapper[role] ?? "user";
+
+        if (!visionModel || typeof content === "string") {
+          return {
+            role: insideRole,
+            content: getMessageTextContent(v),
+          };
+        }
+        return {
+          role: insideRole,
+          content: content
+            .filter((v) => v.image_url || v.text)
+            .map(({ type, text, image_url }) => {
+              if (type === "text") {
+                return {
+                  type,
+                  text: text!,
+                };
+              }
+              const { url = "" } = image_url || {};
+              const colonIndex = url.indexOf(":");
+              const semicolonIndex = url.indexOf(";");
+              const comma = url.indexOf(",");
+
+              const mimeType = url.slice(colonIndex + 1, semicolonIndex);
+              const encodeType = url.slice(semicolonIndex + 1, comma);
+              const data = url.slice(comma + 1);
+
+              return {
+                type: "image" as const,
+                source: {
+                  type: encodeType,
+                  media_type: mimeType,
+                  data,
+                },
+              };
+            }),
+        };
+      });
+
+    if (prompt[0]?.role === "assistant") {
+      prompt.unshift({
+        role: "user",
+        content: ";",
+      });
+    }
+
+    const [tools, funcs] = usePluginStore
+      .getState()
+      .getAsTools(useChatStore.getState().currentSession().mask?.plugin || []);
+
+    const requestBody = {
+      modelId: options.config.model,
+      messages: messages.filter((msg) => msg.content.length > 0),
+      inferenceConfig: {
+        maxTokens: modelConfig.max_tokens,
+        temperature: modelConfig.temperature,
+        topP: modelConfig.top_p,
+        stopSequences: [],
+      },
+      toolConfig:
+        Array.isArray(tools) && tools.length > 0
+          ? {
+              tools: tools.map((tool: any) => ({
+                toolSpec: {
+                  name: tool?.function?.name,
+                  description: tool?.function?.description,
+                  inputSchema: {
+                    json: tool?.function?.parameters,
+                  },
+                },
+              })),
+              toolChoice: { auto: {} },
+            }
+          : undefined,
+    };
+
+    const conversePath = `${ApiPath.Bedrock}/converse`;
+    const controller = new AbortController();
+    options.onController?.(controller);
+
+    if (shouldStream) {
+      let currentToolUse: ChatMessageTool | null = null;
+      return stream(
+        conversePath,
+        requestBody,
+        getHeaders(),
+        Array.isArray(tools)
+          ? tools.map((tool: any) => ({
+              name: tool?.function?.name,
+              description: tool?.function?.description,
+              input_schema: tool?.function?.parameters,
+            }))
+          : [],
+        funcs,
+        controller,
+        // parseSSE
+        (text: string, runTools: ChatMessageTool[]) => {
+          const parsed = JSON.parse(text);
+          const event = parsed.stream;
+
+          if (!event) {
+            console.warn("[Bedrock] Unexpected event format:", parsed);
+            return "";
+          }
+
+          if (event.messageStart) {
+            return "";
+          }
+
+          if (event.contentBlockStart?.start?.toolUse) {
+            const { toolUseId, name } = event.contentBlockStart.start.toolUse;
+            currentToolUse = {
+              id: toolUseId,
+              type: "function",
+              function: {
+                name,
+                arguments: "",
+              },
+            };
+            runTools.push(currentToolUse);
+            return "";
+          }
+
+          if (event.contentBlockDelta?.delta?.text) {
+            return event.contentBlockDelta.delta.text;
+          }
+
+          if (
+            event.contentBlockDelta?.delta?.toolUse?.input &&
+            currentToolUse?.function
+          ) {
+            currentToolUse.function.arguments +=
+              event.contentBlockDelta.delta.toolUse.input;
+            return "";
+          }
+
+          if (
+            event.internalServerException ||
+            event.modelStreamErrorException ||
+            event.validationException ||
+            event.throttlingException ||
+            event.serviceUnavailableException
+          ) {
+            const errorMessage =
+              event.internalServerException?.message ||
+              event.modelStreamErrorException?.message ||
+              event.validationException?.message ||
+              event.throttlingException?.message ||
+              event.serviceUnavailableException?.message ||
+              "Unknown error";
+            throw new Error(errorMessage);
+          }
+
+          return "";
+        },
+        // processToolMessage
+        (requestPayload: any, toolCallMessage: any, toolCallResult: any[]) => {
+          currentToolUse = null;
+          requestPayload?.messages?.splice(
+            requestPayload?.messages?.length,
+            0,
+            {
+              role: "assistant",
+              content: toolCallMessage.tool_calls.map(
+                (tool: ChatMessageTool) => ({
+                  type: "tool_use",
+                  id: tool.id,
+                  name: tool?.function?.name,
+                  input: tool?.function?.arguments
+                    ? JSON.parse(tool?.function?.arguments)
+                    : {},
+                }),
+              ),
+            },
+            ...toolCallResult.map((result) => ({
+              role: "user",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: result.tool_call_id,
+                  content: result.content,
+                },
+              ],
+            })),
+          );
+        },
+        options,
+      );
+    } else {
+      try {
+        const response = await fetch(conversePath, {
+          method: "POST",
+          headers: getHeaders(),
+          body: JSON.stringify(requestBody),
+          signal: controller.signal,
+        });
+
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Bedrock API error: ${error}`);
+        }
+
+        const responseBody = await response.json();
+        const content = this.extractMessage(responseBody);
+        options.onFinish(content);
+      } catch (e: any) {
+        console.error("[Bedrock] Chat error:", e);
+        throw e;
+      }
+    }
+  }
+}
--- a/app/client/platforms/glm.ts
+++ b/app/client/platforms/glm.ts
@@ -1,197 +0,0 @@
-"use client";
-import {
-  ApiPath,
-  CHATGLM_BASE_URL,
-  ChatGLM,
-  REQUEST_TIMEOUT_MS,
-} from "@/app/constant";
-import {
-  useAccessStore,
-  useAppConfig,
-  useChatStore,
-  ChatMessageTool,
-  usePluginStore,
-} from "@/app/store";
-import { stream } from "@/app/utils/chat";
-import {
-  ChatOptions,
-  getHeaders,
-  LLMApi,
-  LLMModel,
-  SpeechOptions,
-} from "../api";
-import { getClientConfig } from "@/app/config/client";
-import { getMessageTextContent } from "@/app/utils";
-import { RequestPayload } from "./openai";
-import { fetch } from "@/app/utils/stream";
-
-export class ChatGLMApi implements LLMApi {
-  private disableListModels = true;
-
-  path(path: string): string {
-    const accessStore = useAccessStore.getState();
-
-    let baseUrl = "";
-
-    if (accessStore.useCustomConfig) {
-      baseUrl = accessStore.chatglmUrl;
-    }
-
-    if (baseUrl.length === 0) {
-      const isApp = !!getClientConfig()?.isApp;
-      const apiPath = ApiPath.ChatGLM;
-      baseUrl = isApp ? CHATGLM_BASE_URL : apiPath;
-    }
-
-    if (baseUrl.endsWith("/")) {
-      baseUrl = baseUrl.slice(0, baseUrl.length - 1);
-    }
-    if (!baseUrl.startsWith("http") && !baseUrl.startsWith(ApiPath.ChatGLM)) {
-      baseUrl = "https://" + baseUrl;
-    }
-
-    console.log("[Proxy Endpoint] ", baseUrl, path);
-
-    return [baseUrl, path].join("/");
-  }
-
-  extractMessage(res: any) {
-    return res.choices?.at(0)?.message?.content ?? "";
-  }
-
-  speech(options: SpeechOptions): Promise<ArrayBuffer> {
-    throw new Error("Method not implemented.");
-  }
-
-  async chat(options: ChatOptions) {
-    const messages: ChatOptions["messages"] = [];
-    for (const v of options.messages) {
-      const content = getMessageTextContent(v);
-      messages.push({ role: v.role, content });
-    }
-
-    const modelConfig = {
-      ...useAppConfig.getState().modelConfig,
-      ...useChatStore.getState().currentSession().mask.modelConfig,
-      ...{
-        model: options.config.model,
-        providerName: options.config.providerName,
-      },
-    };
-
-    const requestPayload: RequestPayload = {
-      messages,
-      stream: options.config.stream,
-      model: modelConfig.model,
-      temperature: modelConfig.temperature,
-      presence_penalty: modelConfig.presence_penalty,
-      frequency_penalty: modelConfig.frequency_penalty,
-      top_p: modelConfig.top_p,
-    };
-
-    console.log("[Request] glm payload: ", requestPayload);
-
-    const shouldStream = !!options.config.stream;
-    const controller = new AbortController();
-    options.onController?.(controller);
-
-    try {
-      const chatPath = this.path(ChatGLM.ChatPath);
-      const chatPayload = {
-        method: "POST",
-        body: JSON.stringify(requestPayload),
-        signal: controller.signal,
-        headers: getHeaders(),
-      };
-
-      // make a fetch request
-      const requestTimeoutId = setTimeout(
-        () => controller.abort(),
-        REQUEST_TIMEOUT_MS,
-      );
-
-      if (shouldStream) {
-        const [tools, funcs] = usePluginStore
-          .getState()
-          .getAsTools(
-            useChatStore.getState().currentSession().mask?.plugin || [],
-          );
-        return stream(
-          chatPath,
-          requestPayload,
-          getHeaders(),
-          tools as any,
-          funcs,
-          controller,
-          // parseSSE
-          (text: string, runTools: ChatMessageTool[]) => {
-            // console.log("parseSSE", text, runTools);
-            const json = JSON.parse(text);
-            const choices = json.choices as Array<{
-              delta: {
-                content: string;
-                tool_calls: ChatMessageTool[];
-              };
-            }>;
-            const tool_calls = choices[0]?.delta?.tool_calls;
-            if (tool_calls?.length > 0) {
-              const index = tool_calls[0]?.index;
-              const id = tool_calls[0]?.id;
-              const args = tool_calls[0]?.function?.arguments;
-              if (id) {
-                runTools.push({
-                  id,
-                  type: tool_calls[0]?.type,
-                  function: {
-                    name: tool_calls[0]?.function?.name as string,
-                    arguments: args,
-                  },
-                });
-              } else {
-                // @ts-ignore
-                runTools[index]["function"]["arguments"] += args;
-              }
-            }
-            return choices[0]?.delta?.content;
-          },
-          // processToolMessage, include tool_calls message and tool call results
-          (
-            requestPayload: RequestPayload,
-            toolCallMessage: any,
-            toolCallResult: any[],
-          ) => {
-            // @ts-ignore
-            requestPayload?.messages?.splice(
-              // @ts-ignore
-              requestPayload?.messages?.length,
-              0,
-              toolCallMessage,
-              ...toolCallResult,
-            );
-          },
-          options,
-        );
-      } else {
-        const res = await fetch(chatPath, chatPayload);
-        clearTimeout(requestTimeoutId);
-
-        const resJson = await res.json();
-        const message = this.extractMessage(resJson);
-        options.onFinish(message);
-      }
-    } catch (e) {
-      console.log("[Request] failed to make a chat request", e);
-      options.onError?.(e as Error);
-    }
-  }
-  async usage() {
-    return {
-      used: 0,
-      total: 0,
-    };
-  }
-
-  async models(): Promise<LLMModel[]> {
-    return [];
-  }
-}
--- a/app/components/chat.module.scss
+++ b/app/components/chat.module.scss
@@ -75,6 +75,17 @@
      pointer-events: none;
    }

+    .icon {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+
+      svg {
+        width: 16px;
+        height: 16px;
+      }
+    }
+
    &:hover {
      --delay: 0.5s;
      width: var(--full-width);
@@ -393,8 +404,8 @@

    button {
      padding: 7px;
-    }
  }
+}

  /* Specific styles for iOS devices */
  @media screen and (max-device-width: 812px) and (-webkit-min-device-pixel-ratio: 2) {
--- a/app/components/settings.tsx
+++ b/app/components/settings.tsx
@@ -72,7 +72,6 @@ import {
  Stability,
  Iflytek,
  SAAS_CHAT_URL,
-  ChatGLM,
 } from "../constant";
 import { Prompt, SearchService, usePromptStore } from "../store/prompt";
 import { ErrorBoundary } from "./error";
@@ -964,7 +963,75 @@ export function Settings() {
      </ListItem>
    </>
  );
-
+  const bedrockConfigComponent = accessStore.provider ===
+    ServiceProvider.Bedrock && (
+    <>
+      <ListItem
+        title={Locale.Settings.Access.Bedrock.Region.Title}
+        subTitle={Locale.Settings.Access.Bedrock.Region.SubTitle}
+      >
+        <input
+          aria-label={Locale.Settings.Access.Bedrock.Region.Title}
+          type="text"
+          value={accessStore.awsRegion}
+          placeholder="us-west-2"
+          onChange={(e) =>
+            accessStore.update(
+              (access) => (access.awsRegion = e.currentTarget.value),
+            )
+          }
+        />
+      </ListItem>
+      <ListItem
+        title={Locale.Settings.Access.Bedrock.AccessKey.Title}
+        subTitle={Locale.Settings.Access.Bedrock.AccessKey.SubTitle}
+      >
+        <PasswordInput
+          aria-label={Locale.Settings.Access.Bedrock.AccessKey.Title}
+          value={accessStore.awsAccessKey}
+          type="text"
+          placeholder={Locale.Settings.Access.Bedrock.AccessKey.Placeholder}
+          onChange={(e) => {
+            accessStore.update(
+              (access) => (access.awsAccessKey = e.currentTarget.value),
+            );
+          }}
+        />
+      </ListItem>
+      <ListItem
+        title={Locale.Settings.Access.Bedrock.SecretKey.Title}
+        subTitle={Locale.Settings.Access.Bedrock.SecretKey.SubTitle}
+      >
+        <PasswordInput
+          aria-label={Locale.Settings.Access.Bedrock.SecretKey.Title}
+          value={accessStore.awsSecretKey}
+          type="text"
+          placeholder={Locale.Settings.Access.Bedrock.SecretKey.Placeholder}
+          onChange={(e) => {
+            accessStore.update(
+              (access) => (access.awsSecretKey = e.currentTarget.value),
+            );
+          }}
+        />
+      </ListItem>
+      <ListItem
+        title={Locale.Settings.Access.Bedrock.SessionToken.Title}
+        subTitle={Locale.Settings.Access.Bedrock.SessionToken.SubTitle}
+      >
+        <PasswordInput
+          aria-label={Locale.Settings.Access.Bedrock.SessionToken.Title}
+          value={accessStore.awsSessionToken}
+          type="text"
+          placeholder={Locale.Settings.Access.Bedrock.SessionToken.Placeholder}
+          onChange={(e) => {
+            accessStore.update(
+              (access) => (access.awsSessionToken = e.currentTarget.value),
+            );
+          }}
+        />
+      </ListItem>
+    </>
+  );
  const baiduConfigComponent = accessStore.provider ===
    ServiceProvider.Baidu && (
    <>
@@ -1235,47 +1302,6 @@ export function Settings() {
    </>
  );

-  const chatglmConfigComponent = accessStore.provider ===
-    ServiceProvider.ChatGLM && (
-    <>
-      <ListItem
-        title={Locale.Settings.Access.ChatGLM.Endpoint.Title}
-        subTitle={
-          Locale.Settings.Access.ChatGLM.Endpoint.SubTitle +
-          ChatGLM.ExampleEndpoint
-        }
-      >
-        <input
-          aria-label={Locale.Settings.Access.ChatGLM.Endpoint.Title}
-          type="text"
-          value={accessStore.chatglmUrl}
-          placeholder={ChatGLM.ExampleEndpoint}
-          onChange={(e) =>
-            accessStore.update(
-              (access) => (access.chatglmUrl = e.currentTarget.value),
-            )
-          }
-        ></input>
-      </ListItem>
-      <ListItem
-        title={Locale.Settings.Access.ChatGLM.ApiKey.Title}
-        subTitle={Locale.Settings.Access.ChatGLM.ApiKey.SubTitle}
-      >
-        <PasswordInput
-          aria-label={Locale.Settings.Access.ChatGLM.ApiKey.Title}
-          value={accessStore.chatglmApiKey}
-          type="text"
-          placeholder={Locale.Settings.Access.ChatGLM.ApiKey.Placeholder}
-          onChange={(e) => {
-            accessStore.update(
-              (access) => (access.chatglmApiKey = e.currentTarget.value),
-            );
-          }}
-        />
-      </ListItem>
-    </>
-  );
-
  const stabilityConfigComponent = accessStore.provider ===
    ServiceProvider.Stability && (
    <>
@@ -1724,6 +1750,7 @@ export function Settings() {
                  </ListItem>

                  {openAIConfigComponent}
+                  {bedrockConfigComponent}
                  {azureConfigComponent}
                  {googleConfigComponent}
                  {anthropicConfigComponent}
@@ -1735,7 +1762,6 @@ export function Settings() {
                  {stabilityConfigComponent}
                  {lflytekConfigComponent}
                  {XAIConfigComponent}
-                  {chatglmConfigComponent}
                </>
              )}
            </>
--- a/app/config/server.ts
+++ b/app/config/server.ts
@@ -12,6 +12,11 @@ declare global {
      BASE_URL?: string;
      OPENAI_ORG_ID?: string; // openai only

+      // bedrock only
+      BEDROCK_REGION?: string;
+      BEDROCK_API_KEY?: string;
+      BEDROCK_API_SECRET?: string;
+
      VERCEL?: string;
      BUILD_MODE?: "standalone" | "export";
      BUILD_APP?: string; // is building desktop app
@@ -75,10 +80,6 @@ declare global {
      XAI_URL?: string;
      XAI_API_KEY?: string;

-      // chatglm only
-      CHATGLM_URL?: string;
-      CHATGLM_API_KEY?: string;
-
      // custom template for preprocessing user input
      DEFAULT_INPUT_TEMPLATE?: string;
    }
@@ -143,7 +144,7 @@ export const getServerSideConfig = () => {
  }

  const isStability = !!process.env.STABILITY_API_KEY;
-
+  const isBedrock = !!process.env.BEDROCK_API_KEY;
  const isAzure = !!process.env.AZURE_URL;
  const isGoogle = !!process.env.GOOGLE_API_KEY;
  const isAnthropic = !!process.env.ANTHROPIC_API_KEY;
@@ -155,7 +156,6 @@ export const getServerSideConfig = () => {
  const isMoonshot = !!process.env.MOONSHOT_API_KEY;
  const isIflytek = !!process.env.IFLYTEK_API_KEY;
  const isXAI = !!process.env.XAI_API_KEY;
-  const isChatGLM = !!process.env.CHATGLM_API_KEY;
  // const apiKeyEnvVar = process.env.OPENAI_API_KEY ?? "";
  // const apiKeys = apiKeyEnvVar.split(",").map((v) => v.trim());
  // const randomIndex = Math.floor(Math.random() * apiKeys.length);
@@ -173,6 +173,11 @@ export const getServerSideConfig = () => {
    apiKey: getApiKey(process.env.OPENAI_API_KEY),
    openaiOrgId: process.env.OPENAI_ORG_ID,

+    isBedrock,
+    awsRegion: process.env.AWS_REGION,
+    awsAccessKey: process.env.AWS_ACCESS_KEY,
+    awsSecretKey: process.env.AWS_SECRET_KEY,
+
    isStability,
    stabilityUrl: process.env.STABILITY_URL,
    stabilityApiKey: getApiKey(process.env.STABILITY_API_KEY),
@@ -222,10 +227,6 @@ export const getServerSideConfig = () => {
    xaiUrl: process.env.XAI_URL,
    xaiApiKey: getApiKey(process.env.XAI_API_KEY),

-    isChatGLM,
-    chatglmUrl: process.env.CHATGLM_URL,
-    chatglmApiKey: getApiKey(process.env.CHATGLM_API_KEY),
-
    cloudflareAccountId: process.env.CLOUDFLARE_ACCOUNT_ID,
    cloudflareKVNamespaceId: process.env.CLOUDFLARE_KV_NAMESPACE_ID,
    cloudflareKVApiKey: getApiKey(process.env.CLOUDFLARE_KV_API_KEY),
--- a/app/constant.ts
+++ b/app/constant.ts
@@ -12,6 +12,8 @@ export const RUNTIME_CONFIG_DOM = "danger-runtime-config";
 export const STABILITY_BASE_URL = "https://api.stability.ai";

 export const OPENAI_BASE_URL = "https://api.openai.com";
+export const BEDROCK_BASE_URL =
+  "https://bedrock-runtime.us-west-2.amazonaws.com";
 export const ANTHROPIC_BASE_URL = "https://api.anthropic.com";

 export const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/";
@@ -30,8 +32,6 @@ export const IFLYTEK_BASE_URL = "https://spark-api-open.xf-yun.com";

 export const XAI_BASE_URL = "https://api.x.ai";

-export const CHATGLM_BASE_URL = "https://open.bigmodel.cn";
-
 export const CACHE_URL_PREFIX = "/api/cache";
 export const UPLOAD_URL = `${CACHE_URL_PREFIX}/upload`;

@@ -51,6 +51,7 @@ export enum Path {

 export enum ApiPath {
  Cors = "",
+  Bedrock = "/api/bedrock",
  Azure = "/api/azure",
  OpenAI = "/api/openai",
  Anthropic = "/api/anthropic",
@@ -64,7 +65,6 @@ export enum ApiPath {
  Stability = "/api/stability",
  Artifacts = "/api/artifacts",
  XAI = "/api/xai",
-  ChatGLM = "/api/chatglm",
 }

 export enum SlotID {
@@ -118,7 +118,7 @@ export enum ServiceProvider {
  Stability = "Stability",
  Iflytek = "Iflytek",
  XAI = "XAI",
-  ChatGLM = "ChatGLM",
+  Bedrock = "Bedrock",
 }

 // Google API safety settings, see https://ai.google.dev/gemini-api/docs/safety-settings
@@ -132,6 +132,7 @@ export enum GoogleSafetySettingsThreshold {

 export enum ModelProvider {
  Stability = "Stability",
+  Bedrock = "Bedrock",
  GPT = "GPT",
  GeminiPro = "GeminiPro",
  Claude = "Claude",
@@ -142,7 +143,6 @@ export enum ModelProvider {
  Moonshot = "Moonshot",
  Iflytek = "Iflytek",
  XAI = "XAI",
-  ChatGLM = "ChatGLM",
 }

 export const Stability = {
@@ -230,9 +230,8 @@ export const XAI = {
  ChatPath: "v1/chat/completions",
 };

-export const ChatGLM = {
-  ExampleEndpoint: CHATGLM_BASE_URL,
-  ChatPath: "/api/paas/v4/chat/completions",
+export const Bedrock = {
+  ChatPath: "converse",
 };

 export const DEFAULT_INPUT_TEMPLATE = `{{input}}`; // input / time / model / lang
@@ -314,6 +313,22 @@ const openaiModels = [
  "o1-preview",
 ];

+const bedrockModels = [
+  // Claude Models
+  "anthropic.claude-3-haiku-20240307-v1:0",
+  "anthropic.claude-3-5-haiku-20241022-v1:0",
+  "anthropic.claude-3-sonnet-20240229-v1:0",
+  "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "anthropic.claude-3-opus-20240229-v1:0",
+
+  // Meta Llama Models
+  "us.meta.llama3-2-11b-instruct-v1:0",
+  "us.meta.llama3-2-90b-instruct-v1:0",
+  //Mistral
+  "mistral.mistral-large-2402-v1:0",
+  "mistral.mistral-large-2407-v1:0",
+];
+
 const googleModels = [
  "gemini-1.0-pro",
  "gemini-1.5-pro-latest",
@@ -389,17 +404,6 @@ const iflytekModels = [

 const xAIModes = ["grok-beta"];

-const chatglmModels = [
-  "glm-4-plus",
-  "glm-4-0520",
-  "glm-4",
-  "glm-4-air",
-  "glm-4-airx",
-  "glm-4-long",
-  "glm-4-flashx",
-  "glm-4-flash",
-];
-
 let seq = 1000; // 内置的模型序号生成器从1000开始
 export const DEFAULT_MODELS = [
  ...openaiModels.map((name) => ({
@@ -523,15 +527,15 @@ export const DEFAULT_MODELS = [
      sorted: 11,
    },
  })),
-  ...chatglmModels.map((name) => ({
+  ...bedrockModels.map((name) => ({
    name,
    available: true,
    sorted: seq++,
    provider: {
-      id: "chatglm",
-      providerName: "ChatGLM",
-      providerType: "chatglm",
-      sorted: 12,
+      id: "bedrock",
+      providerName: "Bedrock",
+      providerType: "bedrock",
+      sorted: 13,
    },
  })),
 ] as const;
--- a/app/locales/cn.ts
+++ b/app/locales/cn.ts
@@ -81,6 +81,7 @@ const cn = {
      Clear: "清除聊天",
      Settings: "对话设置",
      UploadImage: "上传图片",
+      UploadDocument: "上传文档",
    },
    Rename: "重命名对话",
    Typing: "正在输入…",
@@ -342,6 +343,32 @@ const cn = {
          SubTitle: "除默认地址外，必须包含 http(s)://",
        },
      },
+      Bedrock: {
+        Region: {
+          Title: "AWS Region",
+          SubTitle: "The AWS region where Bedrock service is located",
+          Placeholder: "us-west-2",
+        },
+        AccessKey: {
+          Title: "AWS Access Key ID",
+          SubTitle: "Your AWS access key ID for Bedrock service",
+          Placeholder: "AKIA...",
+        },
+        SecretKey: {
+          Title: "AWS Secret Access Key",
+          SubTitle: "Your AWS secret access key for Bedrock service",
+          Placeholder: "****",
+        },
+        SessionToken: {
+          Title: "AWS Session Token (Optional)",
+          SubTitle: "Your AWS session token if using temporary credentials",
+          Placeholder: "Optional session token",
+        },
+        Endpoint: {
+          Title: "AWS Bedrock Endpoint",
+          SubTitle: "Custom endpoint for AWS Bedrock API. Default: ",
+        },
+      },
      Azure: {
        ApiKey: {
          Title: "接口密钥",
@@ -473,17 +500,6 @@ const cn = {
          SubTitle: "样例：",
        },
      },
-      ChatGLM: {
-        ApiKey: {
-          Title: "接口密钥",
-          SubTitle: "使用自定义 ChatGLM API Key",
-          Placeholder: "ChatGLM API Key",
-        },
-        Endpoint: {
-          Title: "接口地址",
-          SubTitle: "样例：",
-        },
-      },
      Stability: {
        ApiKey: {
          Title: "接口密钥",
--- a/app/locales/en.ts
+++ b/app/locales/en.ts
@@ -82,6 +82,7 @@ const en: LocaleType = {
      Clear: "Clear Context",
      Settings: "Settings",
      UploadImage: "Upload Images",
+      UploadDocument: "Upload Documents",
    },
    Rename: "Rename Chat",
    Typing: "Typing…",
@@ -346,6 +347,32 @@ const en: LocaleType = {
          SubTitle: "Must start with http(s):// or use /api/openai as default",
        },
      },
+      Bedrock: {
+        Region: {
+          Title: "AWS Region",
+          SubTitle: "The AWS region where Bedrock service is located",
+          Placeholder: "us-west-2",
+        },
+        AccessKey: {
+          Title: "AWS Access Key ID",
+          SubTitle: "Your AWS access key ID for Bedrock service",
+          Placeholder: "AKIA...",
+        },
+        SecretKey: {
+          Title: "AWS Secret Access Key",
+          SubTitle: "Your AWS secret access key for Bedrock service",
+          Placeholder: "****",
+        },
+        SessionToken: {
+          Title: "AWS Session Token (Optional)",
+          SubTitle: "Your AWS session token if using temporary credentials",
+          Placeholder: "Optional session token",
+        },
+        Endpoint: {
+          Title: "AWS Bedrock Endpoint",
+          SubTitle: "Custom endpoint for AWS Bedrock API. Default: ",
+        },
+      },
      Azure: {
        ApiKey: {
          Title: "Azure Api Key",
@@ -457,17 +484,6 @@ const en: LocaleType = {
          SubTitle: "Example: ",
        },
      },
-      ChatGLM: {
-        ApiKey: {
-          Title: "ChatGLM API Key",
-          SubTitle: "Use a custom ChatGLM API Key",
-          Placeholder: "ChatGLM API Key",
-        },
-        Endpoint: {
-          Title: "Endpoint Address",
-          SubTitle: "Example: ",
-        },
-      },
      Stability: {
        ApiKey: {
          Title: "Stability API Key",
--- a/app/store/access.ts
+++ b/app/store/access.ts
@@ -4,6 +4,7 @@ import {
  StoreKey,
  ApiPath,
  OPENAI_BASE_URL,
+  BEDROCK_BASE_URL,
  ANTHROPIC_BASE_URL,
  GEMINI_BASE_URL,
  BAIDU_BASE_URL,
@@ -14,7 +15,6 @@ import {
  STABILITY_BASE_URL,
  IFLYTEK_BASE_URL,
  XAI_BASE_URL,
-  CHATGLM_BASE_URL,
 } from "../constant";
 import { getHeaders } from "../client/api";
 import { getClientConfig } from "../config/client";
@@ -27,6 +27,7 @@ let fetchState = 0; // 0 not fetch, 1 fetching, 2 done
 const isApp = getClientConfig()?.buildMode === "export";

 const DEFAULT_OPENAI_URL = isApp ? OPENAI_BASE_URL : ApiPath.OpenAI;
+const DEFAULT_BEDROCK_URL = isApp ? BEDROCK_BASE_URL : ApiPath.Bedrock;

 const DEFAULT_GOOGLE_URL = isApp ? GEMINI_BASE_URL : ApiPath.Google;

@@ -48,8 +49,6 @@ const DEFAULT_IFLYTEK_URL = isApp ? IFLYTEK_BASE_URL : ApiPath.Iflytek;

 const DEFAULT_XAI_URL = isApp ? XAI_BASE_URL : ApiPath.XAI;

-const DEFAULT_CHATGLM_URL = isApp ? CHATGLM_BASE_URL : ApiPath.ChatGLM;
-
 const DEFAULT_ACCESS_STATE = {
  accessCode: "",
  useCustomConfig: false,
@@ -60,6 +59,13 @@ const DEFAULT_ACCESS_STATE = {
  openaiUrl: DEFAULT_OPENAI_URL,
  openaiApiKey: "",

+  // bedrock
+  awsRegion: "",
+  awsAccessKey: "",
+  awsSecretKey: "",
+  awsSessionToken: "",
+  awsCognitoUser: false,
+
  // azure
  azureUrl: "",
  azureApiKey: "",
@@ -111,10 +117,6 @@ const DEFAULT_ACCESS_STATE = {
  xaiUrl: DEFAULT_XAI_URL,
  xaiApiKey: "",

-  // chatglm
-  chatglmUrl: DEFAULT_CHATGLM_URL,
-  chatglmApiKey: "",
-
  // server config
  needCode: true,
  hideUserApiKey: false,
@@ -148,6 +150,10 @@ export const useAccessStore = createPersistStore(
      return ensure(get(), ["openaiApiKey"]);
    },

+    isValidBedrock() {
+      return ensure(get(), ["awsAccessKey", "awsSecretKey", "awsRegion"]);
+    },
+
    isValidAzure() {
      return ensure(get(), ["azureUrl", "azureApiKey", "azureApiVersion"]);
    },
@@ -187,16 +193,13 @@ export const useAccessStore = createPersistStore(
      return ensure(get(), ["xaiApiKey"]);
    },

-    isValidChatGLM() {
-      return ensure(get(), ["chatglmApiKey"]);
-    },
-
    isAuthorized() {
      this.fetch();

      // has token or has code or disabled access control
      return (
        this.isValidOpenAI() ||
+        this.isValidBedrock() ||
        this.isValidAzure() ||
        this.isValidGoogle() ||
        this.isValidAnthropic() ||
@@ -207,7 +210,6 @@ export const useAccessStore = createPersistStore(
        this.isValidMoonshot() ||
        this.isValidIflytek() ||
        this.isValidXAI() ||
-        this.isValidChatGLM() ||
        !this.enabledAccessControl() ||
        (this.enabledAccessControl() && ensure(get(), ["accessCode"]))
      );
--- a/app/utils.ts
+++ b/app/utils.ts
@@ -278,14 +278,16 @@ export function showPlugins(provider: ServiceProvider, model: string) {
  if (
    provider == ServiceProvider.OpenAI ||
    provider == ServiceProvider.Azure ||
-    provider == ServiceProvider.Moonshot ||
-    provider == ServiceProvider.ChatGLM
+    provider == ServiceProvider.Moonshot
  ) {
    return true;
  }
  if (provider == ServiceProvider.Anthropic && !model.includes("claude-2")) {
    return true;
  }
+  if (provider == ServiceProvider.Bedrock && !model.includes("claude-2")) {
+    return true;
+  }
  if (provider == ServiceProvider.Google && !model.includes("vision")) {
    return true;
  }
--- a/docs/bt-cn.md
+++ b/docs/bt-cn.md
@@ -1,29 +0,0 @@
-# 宝塔面板 的部署说明
-
-## 拥有自己的宝塔
-当你需要通过 宝塔面板 部署本项目之前，需要在服务器上先安装好 宝塔面板工具。 接下来的 部署流程 都建立在已有宝塔面板的前提下。宝塔安装请参考 ([宝塔官网](https://www.bt.cn/new/download.html))
-
-> 注意：本项目需要宝塔面板版本 9.2.0 及以上
-
-## 一键安装
-![bt-install-1](./images/bt/bt-install-1.jpeg)
-1. 在 宝塔面板 -> Docker -> 应用商店 页面，搜索 ChatGPT-Next-Web 找到本项目的docker应用；
-2. 点击 安装 开始部署本项目
-
-![bt-install-2](./images/bt/bt-install-2.jpeg)
-1. 在项目配置页，根据要求开始配置环境变量；
-2. 如勾选 允许外部访问 配置，请注意为配置的 web端口 开放安全组端口访问权限；
-3. 请确保你添加了正确的 Open Api Key，否则无法使用；当配置 OpenAI官方 提供的key(国内无法访问)，请配置代理地址；
-4. 建议配置 访问权限密码，否则部署后所有人均可使用已配置的 Open Api Key(当允许外部访问时)；
-5. 点击 确认 开始自动部署。
-
-## 如何访问
-![bt-install-3](./images/bt/bt-install-3.jpeg)
-通过根据 服务器IP地址 和配置的 web端口 http://$(host):$(port)，在浏览器中打开 ChatGPT-Next-Web。
-
-![bt-install-4](./images/bt/bt-install-4.jpeg)
-若配置了 访问权限密码，访问大模型前需要登录，请点击 登录，获取访问权限。
-
-![bt-install-5](./images/bt/bt-install-5.jpeg)
-
-![bt-install-6](./images/bt/bt-install-6.jpeg)
--- a/docs/images/bt/bt-install-1.jpeg
+++ b/docs/images/bt/bt-install-1.jpeg
--- a/docs/images/bt/bt-install-2.jpeg
+++ b/docs/images/bt/bt-install-2.jpeg
--- a/docs/images/bt/bt-install-3.jpeg
+++ b/docs/images/bt/bt-install-3.jpeg
--- a/docs/images/bt/bt-install-4.jpeg
+++ b/docs/images/bt/bt-install-4.jpeg
--- a/docs/images/bt/bt-install-5.jpeg
+++ b/docs/images/bt/bt-install-5.jpeg
--- a/docs/images/bt/bt-install-6.jpeg
+++ b/docs/images/bt/bt-install-6.jpeg
--- a/package.json
+++ b/package.json
@@ -51,7 +51,8 @@
    "sass": "^1.59.2",
    "spark-md5": "^3.0.2",
    "use-debounce": "^9.0.4",
-    "zustand": "^4.3.8"
+    "zustand": "^4.3.8",
+    "@aws-sdk/client-bedrock-runtime": "^3.679.0"
  },
  "devDependencies": {
    "@tauri-apps/api": "^1.6.0",
Author	SHA1	Message	Date
glay	afbf5eb541	修改： .env.template 修改： app/api/auth.ts 修改： app/api/bedrock.ts 修改： app/client/api.ts 修改： app/client/platforms/bedrock.ts 修改： app/components/settings.tsx 修改： app/config/server.ts 修改： app/constant.t	2024-11-05 14:27:52 +08:00
glay	0f276f59bb	修改： app/client/platforms/bedrock.ts	2024-11-05 10:34:33 +08:00
glay	fc391168e9	修改： app/api/bedrock.ts 删除： app/api/bedrock/models.ts 删除： app/api/bedrock/utils.ts 修改： app/client/platforms/bedrock.ts 删除： app/components/chat-actions.tsx 修改： app/components/chat.tsx 修改： app/constant.ts 删除： app/icons/document.svg	2024-11-04 16:24:10 +08:00
glay	dca4a0e48f	修改： 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/chat-actions.tsx 修改： app/components/chat.module.scss 修改： app/components/chat.tsx 修改： app/constant.ts 新文件： app/icons/document.svg 修改： app/locales/cn.ts 修改： app/locales/en.ts	2024-10-31 14:23:38 +08:00
glay	722c28839f	Merge branch 'ChatGPTNextWeb:main' into main	2024-10-31 11:51:41 +08:00
glay	ff356f0c8c	修改： 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	2024-10-29 22:20:26 +08:00