Upload 9 files

.cnb.yml

@@ -0,0 +1,36 @@
+"(main)":
+  push:
+    - runner:
+        cpus: 2
+      services:
+        - docker
+      stages:
+        - name: docker login
+          script: docker login -u ${CNB_TOKEN_USER_NAME} -p "${CNB_TOKEN}" ${CNB_DOCKER_REGISTRY}
+        - name: docker build
+          script: docker build -t ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:${CNB_BRANCH} .
+        - name: tag latest if main branch
+          script: |
+            if [ "${CNB_BRANCH}" = "main" ] || [ "${CNB_BRANCH}" = "master" ]; then
+              docker tag ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:${CNB_BRANCH} ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:latest
+            fi
+        - name: docker push
+          script: |
+            docker push ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:${CNB_BRANCH}
+            if [ "${CNB_BRANCH}" = "main" ] || [ "${CNB_BRANCH}" = "master" ]; then
+              docker push ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:latest
+            fi
+$:
+  tag_push:
+    - runner:
+        cpus: 2
+      services:
+        - docker
+      stages:
+        - name: docker login
+          script: docker login -u ${CNB_TOKEN_USER_NAME} -p "${CNB_TOKEN}" ${CNB_DOCKER_REGISTRY}
+        - name: docker build
+          script: docker build -t ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:${CNB_BRANCH} .
+        - name: docker push
+          script: |
+            docker push ${CNB_DOCKER_REGISTRY}/${CNB_REPO_SLUG_LOWERCASE}:${CNB_BRANCH}

Dockerfile

@@ -0,0 +1,21 @@
+# 构建 go 服务镜像
+FROM golang:1.24.1 as builder
+
+ENV GOPROXY="https://mirrors.cloud.tencent.com/go/"
+
+WORKDIR /app
+
+COPY . .
+
+# 构建应用
+RUN CGO_ENABLED=0 GOOS=linux go build -o main .
+
+FROM alpine:latest
+
+ENV TZ="Asia/Shanghai"
+WORKDIR /app
+
+# 从构建阶段复制可执行文件
+COPY --from=builder /app/main .
+
+CMD ["./main"]

go.mod

@@ -0,0 +1,5 @@
+module cnb.cool/0_0/learn/julep
+
+go 1.24.1
+
+require github.com/google/uuid v1.6.0 // indirect

go.sum

@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

handlers.go

@@ -0,0 +1,287 @@
+package main
+
+import (
+	"encoding/json"
+	"errors" // Import errors package
+	"fmt"
+	"log/slog"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// chatCompletionsHandler handles requests to the /v1/chat/completions endpoint.
+func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.Request) {
+	requestID := generateUUID()
+	reqLogger := logger.With("request_id", requestID)
+	reqLogger.Info("Chat completion request received", "method", r.Method, "path", r.URL.Path)
+
+	// ... (Keep Method Check, Authentication, Decode Body, Validation as before) ...
+	// 1. Check Method
+	if r.Method != http.MethodPost {
+		writeJSONError(w, reqLogger, http.StatusMethodNotAllowed, fmt.Sprintf("Method %s not allowed", r.Method), stringPtr("invalid_request_error"), nil, nil)
+		return
+	}
+
+	// 2. Authentication (Basic Example)
+	authHeader := r.Header.Get("Authorization")
+	if authHeader == "" || !strings.HasPrefix(authHeader, "Bearer ") {
+		invalidAuthType := "missing_authorization"
+		if authHeader != "" {
+			invalidAuthType = "invalid_authorization_type"
+		}
+		writeJSONError(w, reqLogger, http.StatusUnauthorized, "Authorization header is required (e.g., 'Bearer YOUR_API_KEY')", &invalidAuthType, nil, nil)
+		return
+	}
+	reqLogger.Debug("Authorization header present") // Changed to Debug
+
+	// 3. Decode Request Body
+	var openaiRequest OpenAIRequest
+	r.Body = http.MaxBytesReader(w, r.Body, 1024*1024) // 1MB limit
+	err := json.NewDecoder(r.Body).Decode(&openaiRequest)
+	if err != nil {
+		var syntaxError *json.SyntaxError
+		var unmarshalTypeError *json.UnmarshalTypeError
+		errMsg := "Invalid JSON request body"
+		errCode := "invalid_json"
+		if errors.As(err, &syntaxError) { // Use errors.As
+			errMsg = fmt.Sprintf("Invalid JSON syntax at offset %d", syntaxError.Offset)
+		} else if errors.As(err, &unmarshalTypeError) { // Use errors.As
+			errMsg = fmt.Sprintf("Invalid type for field '%s', expected %s", unmarshalTypeError.Field, unmarshalTypeError.Type)
+			errCode = "invalid_field_type"
+		} else if err.Error() == "http: request body too large" {
+			errMsg = "Request body exceeds limit (1MB)"
+			errCode = "request_too_large"
+			writeJSONError(w, reqLogger, http.StatusRequestEntityTooLarge, errMsg, stringPtr("invalid_request_error"), &errCode, nil)
+			return
+		}
+		reqLogger.Error("Failed to decode request body", "error", err)
+		writeJSONError(w, reqLogger, http.StatusBadRequest, errMsg, stringPtr("invalid_request_error"), &errCode, nil)
+		return
+	}
+	defer r.Body.Close()
+
+	// 4. Input Validation
+	if len(openaiRequest.Messages) == 0 {
+		reqLogger.Warn("Validation failed: 'messages' field is empty")
+		param := "messages"
+		code := "missing_field"
+		writeJSONError(w, reqLogger, http.StatusBadRequest, "'messages' is a required field and must be a non-empty array", stringPtr("invalid_request_error"), &code, &param)
+		return
+	}
+	if openaiRequest.Model == "" {
+		reqLogger.Warn("Validation failed: 'model' field is empty")
+		param := "model"
+		code := "missing_field"
+		writeJSONError(w, reqLogger, http.StatusBadRequest, "'model' is a required field", stringPtr("invalid_request_error"), &code, &param)
+		return
+	}
+	reqLogger.Info("Request decoded and validated", "model", openaiRequest.Model, "stream_requested", openaiRequest.Stream)
+
+	// 5. Call Real Upstream (Julep)
+	// Pass the request context for timeout/cancellation propagation
+	// Pass request headers for Authorization etc.
+	finalOpenAIResponse, upstreamStatusCode, err := callJulepChat(r.Context(), reqLogger, r.Header, openaiRequest, requestID)
+	if err != nil {
+		reqLogger.Error("Upstream Julep call failed", "error", err, "status_code", upstreamStatusCode)
+		// Use the status code returned by callJulepChat for the client response
+		errType := "upstream_error"
+		if upstreamStatusCode == http.StatusGatewayTimeout {
+			errType = "gateway_timeout"
+		} else if upstreamStatusCode >= 400 && upstreamStatusCode < 500 {
+			errType = "invalid_request_error" // Or map specific Julep 4xx codes
+		}
+		writeJSONError(w, reqLogger, upstreamStatusCode, fmt.Sprintf("Upstream API error: %s", err.Error()), &errType, nil, nil)
+		return
+	}
+
+	// 6. Handle Client Response (using finalOpenAIResponse)
+	isStreaming := openaiRequest.Stream
+
+	if !isStreaming {
+		// 6.a. Send Non-Streaming Response
+		reqLogger.Info("Sending non-streaming response")
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK) // Status OK as the overall operation succeeded
+		if err := json.NewEncoder(w).Encode(finalOpenAIResponse); err != nil {
+			reqLogger.Error("Failed to encode non-streaming response", "error", err)
+		}
+	} else {
+		// 6.b. Send Simulated Streaming Response from the complete Julep data
+		reqLogger.Info("Sending simulated streaming response based on Julep result")
+
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+		// Optional: w.Header().Set("X-Accel-Buffering", "no")
+
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			reqLogger.Error("Streaming unsupported: ResponseWriter does not implement http.Flusher")
+			errType := "internal_server_error"
+			// It's likely too late to send a proper JSON error here if headers were already flushed implicitly.
+			// Best effort: log and potentially send plain text error before trying to write stream headers.
+			http.Error(w, "Internal Server Error: Streaming unsupported", http.StatusInternalServerError)
+			// Attempt to write JSON error anyway, might fail.
+			writeJSONError(w, reqLogger, http.StatusInternalServerError, "Streaming is not supported by the server configuration", &errType, nil, nil)
+			return
+		}
+
+		// Set status code *before* flushing or writing body
+		w.WriteHeader(http.StatusOK)
+		flusher.Flush() // Ensure headers are sent
+
+		// Stream the full response derived from Julep's data
+		err = streamFullResponseAsChunks(w, flusher, reqLogger, finalOpenAIResponse)
+		if err != nil {
+			reqLogger.Error("Error during streaming simulation", "error", err)
+			// Cannot send JSON error now. Client might see incomplete stream.
+		}
+
+		reqLogger.Info("Finished streaming response")
+	}
+}
+
+// streamFullResponseAsChunks takes a complete OpenAIResponse and sends it
+// to the client as a series of SSE chunks, simulating a real stream.
+func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, logger *slog.Logger, fullResp *OpenAIResponse) error {
+	if len(fullResp.Choices) == 0 {
+		logger.Warn("Full response has no choices to stream")
+		// Send DONE immediately if no choices
+		_, err := fmt.Fprintf(w, "data: [DONE]\n\n")
+		if err != nil {
+			return fmt.Errorf("failed to write [DONE] message: %w", err)
+		}
+		flusher.Flush()
+		return nil
+	}
+
+	choice := fullResp.Choices[0] // Assuming only one choice for simplicity
+	createdTime := fullResp.Created
+
+	// --- Send Initial Chunk (Role) ---
+	if choice.Message.Role != "" {
+		roleChunk := OpenAIChunk{
+			ID:      fullResp.ID,
+			Object:  "chat.completion.chunk",
+			Created: createdTime,
+			Model:   fullResp.Model,
+			Choices: []OpenAIChunkChoice{
+				{
+					Index:        choice.Index,
+					Delta:        OpenAIDelta{Role: stringPtr(choice.Message.Role)},
+					FinishReason: nil,
+				},
+			},
+		}
+		if err := sendChunk(w, flusher, logger, roleChunk); err != nil {
+			return fmt.Errorf("failed to send role chunk: %w", err)
+		}
+		time.Sleep(10 * time.Millisecond) // Small delay
+	}
+
+	// --- Send Content Chunks ---
+	content := choice.Message.Content
+	if content != "" {
+		// Simulate streaming by breaking content into smaller parts
+		const chunkSize = 5 // Small chunk size for demonstration
+		for i := 0; i < len(content); i += chunkSize {
+			end := i + chunkSize
+			if end > len(content) {
+				end = len(content)
+			}
+			contentPiece := content[i:end]
+
+			contentChunk := OpenAIChunk{
+				ID:      fullResp.ID,
+				Object:  "chat.completion.chunk",
+				Created: createdTime, // Could update timestamp per chunk if desired
+				Model:   fullResp.Model,
+				Choices: []OpenAIChunkChoice{
+					{
+						Index:        choice.Index,
+						Delta:        OpenAIDelta{Content: stringPtr(contentPiece)},
+						FinishReason: nil,
+					},
+				},
+			}
+			if err := sendChunk(w, flusher, logger, contentChunk); err != nil {
+				return fmt.Errorf("failed to send content chunk: %w", err)
+			}
+			time.Sleep(30 * time.Millisecond) // Simulate generation time between chunks
+		}
+	}
+
+	// --- Send Tool Calls Chunk (if any) ---
+	if len(choice.Message.ToolCalls) > 0 {
+		toolChunk := OpenAIChunk{
+			ID:      fullResp.ID,
+			Object:  "chat.completion.chunk",
+			Created: createdTime,
+			Model:   fullResp.Model,
+			Choices: []OpenAIChunkChoice{
+				{
+					Index:        choice.Index,
+					Delta:        OpenAIDelta{ToolCalls: choice.Message.ToolCalls}, // Send all tool calls in one delta
+					FinishReason: nil,
+				},
+			},
+		}
+		if err := sendChunk(w, flusher, logger, toolChunk); err != nil {
+			return fmt.Errorf("failed to send tool_calls chunk: %w", err)
+		}
+		time.Sleep(10 * time.Millisecond) // Small delay
+	}
+
+	// --- Send Final Chunk (Finish Reason) ---
+	finalChunk := OpenAIChunk{
+		ID:      fullResp.ID,
+		Object:  "chat.completion.chunk",
+		Created: createdTime,
+		Model:   fullResp.Model,
+		Choices: []OpenAIChunkChoice{
+			{
+				Index:        choice.Index,
+				Delta:        OpenAIDelta{}, // Empty delta
+				FinishReason: stringPtr(choice.FinishReason),
+			},
+		},
+	}
+	if err := sendChunk(w, flusher, logger, finalChunk); err != nil {
+		return fmt.Errorf("failed to send final chunk: %w", err)
+	}
+
+	// --- Send DONE message ---
+	logger.Debug("Sending [DONE] message")
+	_, err := fmt.Fprintf(w, "data: [DONE]\n\n")
+	if err != nil {
+		// Log error, but might not reach client if connection closed
+		logger.Error("Failed to write [DONE] message", "error", err)
+		return fmt.Errorf("failed to write [DONE] message: %w", err)
+	}
+	flusher.Flush() // Ensure DONE is sent
+
+	return nil
+}
+
+// sendChunk encodes the chunk to JSON and writes it in SSE format.
+func sendChunk(w http.ResponseWriter, flusher http.Flusher, logger *slog.Logger, chunk OpenAIChunk) error {
+	chunkBytes, err := json.Marshal(chunk)
+	if err != nil {
+		logger.Error("Failed to marshal stream chunk", "error", err, "chunk_id", chunk.ID)
+		return fmt.Errorf("failed to marshal chunk: %w", err)
+	}
+
+	// Write in Server-Sent Event format: data: <json>\n\n
+	_, err = fmt.Fprintf(w, "data: %s\n\n", string(chunkBytes))
+	if err != nil {
+		// Log error, connection might be closed by client
+		logger.Error("Failed to write chunk to response writer", "error", err, "chunk_id", chunk.ID)
+		return fmt.Errorf("failed to write chunk: %w", err)
+	}
+
+	// Flush the buffer to send the chunk immediately
+	flusher.Flush()
+	logger.Debug("Sent chunk", "chunk_id", chunk.ID, "content_length", len(chunkBytes))
+	return nil
+}

main.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+func main() {
+	// 1. Setup Logger
+	// Use JSON handler for structured logging
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelDebug, // Log debug messages and above
+	}))
+	slog.SetDefault(logger) // Set as default logger for convenience
+
+	logger.Info("Starting Stream Converter API Server...")
+
+	// 2. Setup Router (Go 1.22+ ServeMux)
+	mux := http.NewServeMux()
+
+	// Wrap handler with logger middleware (or pass logger directly)
+	chatHandler := func(w http.ResponseWriter, r *http.Request) {
+		chatCompletionsHandler(logger, w, r)
+	}
+	mux.HandleFunc("POST /v1/chat/completions", chatHandler)
+
+	// Add a simple health check endpoint
+	mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+		logger.Debug("Health check accessed")
+	})
+
+	// 3. Configure HTTP Server
+	server := &http.Server{
+		Addr:         ":8080", // Listen on port 8080
+		Handler:      mux,
+		ReadTimeout:  10 * time.Second, // Example timeout values
+		WriteTimeout: 90 * time.Second, // Longer for potential streaming
+		IdleTimeout:  120 * time.Second,
+	}
+
+	// 4. Start Server in a Goroutine
+	go func() {
+		logger.Info("Server listening", "address", server.Addr)
+		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			logger.Error("Server failed to start", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// 5. Graceful Shutdown Handling
+	quit := make(chan os.Signal, 1)
+	// signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	signal.Notify(quit, os.Interrupt, syscall.SIGTERM) // More portable signals
+
+	// Block until a signal is received
+	sig := <-quit
+	logger.Info("Shutdown signal received", "signal", sig.String())
+
+	// Create a context with timeout for shutdown
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// Attempt graceful shutdown
+	if err := server.Shutdown(ctx); err != nil {
+		logger.Error("Server shutdown failed", "error", err)
+		os.Exit(1)
+	}
+
+	logger.Info("Server gracefully stopped")
+}

models.go

@@ -0,0 +1,121 @@
+package main
+
+// --- OpenAI Request Structures ---
+
+// OpenAIRequest represents the incoming request body for chat completions.
+type OpenAIRequest struct {
+	Model            string          `json:"model"`
+	Messages         []OpenAIMessage `json:"messages"`
+	Stream           bool            `json:"stream"`
+	MaxTokens        *int            `json:"max_tokens,omitempty"`        // Pointer for optional field
+	Temperature      *float64        `json:"temperature,omitempty"`       // Pointer for optional field
+	TopP             *float64        `json:"top_p,omitempty"`             // Pointer for optional field
+	Stop             []string        `json:"stop,omitempty"`              // Can be string or array, handle accordingly if needed
+	PresencePenalty  *float64        `json:"presence_penalty,omitempty"`  // Pointer for optional field
+	FrequencyPenalty *float64        `json:"frequency_penalty,omitempty"` // Pointer for optional field
+	Tools            []OpenAITool    `json:"tools,omitempty"`
+	ToolChoice       any             `json:"tool_choice,omitempty"` // Can be string or object
+	// Add other OpenAI parameters as needed
+}
+
+// OpenAIMessage represents a single message in the chat history.
+type OpenAIMessage struct {
+	Role       string           `json:"role"` // "system", "user", "assistant", "tool"
+	Content    string           `json:"content"`
+	Name       *string          `json:"name,omitempty"`         // For tool role
+	ToolCalls  []OpenAIToolCall `json:"tool_calls,omitempty"`   // For assistant message with tool calls
+	ToolCallID *string          `json:"tool_call_id,omitempty"` // For tool role message
+}
+
+// OpenAITool represents a tool definition.
+type OpenAITool struct {
+	Type     string            `json:"type"` // e.g., "function"
+	Function OpenAIFunctionDef `json:"function"`
+}
+
+// OpenAIFunctionDef represents the definition of a function tool.
+type OpenAIFunctionDef struct {
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	Parameters  any    `json:"parameters"` // Typically a map[string]any representing JSON Schema
+}
+
+// --- OpenAI Response Structures (Non-Streaming) ---
+
+// OpenAIResponse represents the full response for a non-streaming chat completion.
+type OpenAIResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`  // "chat.completion"
+	Created int64          `json:"created"` // Unix timestamp
+	Model   string         `json:"model"`
+	Choices []OpenAIChoice `json:"choices"`
+	Usage   *OpenAIUsage   `json:"usage,omitempty"`
+}
+
+// OpenAIChoice represents a single choice in the non-streaming response.
+type OpenAIChoice struct {
+	Index        int           `json:"index"`
+	Message      OpenAIMessage `json:"message"`
+	FinishReason string        `json:"finish_reason"` // "stop", "length", "tool_calls", "content_filter", "function_call" (legacy)
+}
+
+// OpenAIToolCall represents a tool call made by the model.
+type OpenAIToolCall struct {
+	ID       string         `json:"id"`
+	Type     string         `json:"type"` // always "function" for now
+	Function OpenAIFunction `json:"function"`
+}
+
+// OpenAIFunction represents the function call details.
+type OpenAIFunction struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"` // JSON string arguments
+}
+
+// OpenAIUsage represents token usage statistics.
+type OpenAIUsage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// --- OpenAI Response Structures (Streaming) ---
+
+// OpenAIChunk represents a single chunk in a streaming chat completion response.
+type OpenAIChunk struct {
+	ID      string              `json:"id"`
+	Object  string              `json:"object"` // "chat.completion.chunk"
+	Created int64               `json:"created"`
+	Model   string              `json:"model"`
+	Choices []OpenAIChunkChoice `json:"choices"`
+}
+
+// OpenAIChunkChoice represents a choice within a streaming chunk.
+type OpenAIChunkChoice struct {
+	Index        int         `json:"index"`
+	Delta        OpenAIDelta `json:"delta"`                   // The changes in this chunk
+	FinishReason *string     `json:"finish_reason,omitempty"` // Pointer as it's only in the last chunk for a choice
+}
+
+// OpenAIDelta represents the changed fields in a streaming chunk.
+// Only one of these fields will typically be populated in a single chunk.
+type OpenAIDelta struct {
+	Role      *string          `json:"role,omitempty"`       // Pointer for optional field
+	Content   *string          `json:"content,omitempty"`    // Pointer for optional field
+	ToolCalls []OpenAIToolCall `json:"tool_calls,omitempty"` // Sent as a complete array in one chunk
+}
+
+// --- Error Response ---
+
+// ErrorResponse defines the standard JSON error format.
+type ErrorResponse struct {
+	Error APIError `json:"error"`
+}
+
+// APIError defines the structure of the error object.
+type APIError struct {
+	Message string  `json:"message"`
+	Type    *string `json:"type,omitempty"`  // e.g., "invalid_request_error"
+	Param   *string `json:"param,omitempty"` // e.g., "messages"
+	Code    *string `json:"code,omitempty"`  // e.g., "missing_field"
+}

upstream.go

@@ -0,0 +1,388 @@
+package main
+
+import (
+	"bytes"   // 用于创建请求体
+	"context" // 用于超时和取消
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io" // 用于读取响应体
+	"log/slog"
+	"net/http" // 用于 HTTP 请求
+	"os"
+	"strings"
+	"time"
+	// 确保已导入
+)
+
+// JulepApiBaseURL 存储从环境变量读取的上游 API 基础 URL
+var JulepApiBaseURL string
+var apiClient *http.Client // 包级别的 HTTP 客户端
+
+const (
+	defaultTimeout = 30 * time.Second // 默认 HTTP 请求超时
+	chatTimeout    = 90 * time.Second // Chat 请求可能需要更长时间
+)
+
+func init() {
+	JulepApiBaseURL = os.Getenv("JULEP_API_BASE_URL")
+	if JulepApiBaseURL == "" {
+		slog.Error("Fatal: JULEP_API_BASE_URL environment variable not set.")
+		os.Exit(1)
+	}
+	JulepApiBaseURL = strings.TrimSuffix(JulepApiBaseURL, "/")
+	slog.Info("Julep API Base URL configured", "url", JulepApiBaseURL)
+
+	// 创建可复用的 HTTP 客户端
+	apiClient = &http.Client{
+		Timeout: defaultTimeout, // 设置默认超时
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 10,
+			IdleConnTimeout:     90 * time.Second,
+		},
+	}
+	slog.Info("HTTP client initialized")
+}
+
+// --- Julep Specific Request/Response Structs ---
+// (可以放在 models.go 或这里，放在这里让 upstream.go 更独立)
+
+type CreateAgentPayload struct {
+	Name  string `json:"name"`
+	About string `json:"about"`
+	// 添加 Julep Agent 的其他字段...
+}
+
+type CreateSessionPayload struct {
+	AgentID string `json:"agent"` // Julep API 使用 "agent" 字段
+	// 添加 Julep Session 的其他字段...
+}
+
+// JulepMessage mirrors the structure within Julep's chat payload/response
+type JulepMessage struct {
+	Role       string          `json:"role"`
+	Content    string          `json:"content"`
+	Name       *string         `json:"name,omitempty"`
+	ToolCallID *string         `json:"tool_call_id,omitempty"`
+	ToolCalls  []JulepToolCall `json:"tool_calls,omitempty"`
+}
+
+// JulepToolCall mirrors the tool call structure within Julep's format
+type JulepToolCall struct {
+	ID       string        `json:"id"`
+	Type     string        `json:"type"` // e.g., "function"
+	Function JulepFunction `json:"function,omitempty"`
+	// Add other Julep tool call types if needed
+}
+
+// JulepFunction mirrors the function structure within Julep's tool call
+type JulepFunction struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"` // Assuming arguments are a JSON string
+}
+
+// JulepChatPayload represents the body sent to Julep's /chat endpoint
+type JulepChatPayload struct {
+	Messages         []JulepMessage `json:"messages"`
+	Model            *string        `json:"model,omitempty"` // Julep might use model from agent/session
+	Stream           bool           `json:"stream"`          // Julep doesn't stream, but payload might accept it
+	MaxTokens        *int           `json:"max_tokens,omitempty"`
+	Temperature      *float64       `json:"temperature,omitempty"`
+	TopP             *float64       `json:"top_p,omitempty"`
+	Stop             []string       `json:"stop,omitempty"`
+	PresencePenalty  *float64       `json:"presence_penalty,omitempty"`
+	FrequencyPenalty *float64       `json:"frequency_penalty,omitempty"`
+	Tools            []OpenAITool   `json:"tools,omitempty"`       // Assuming Julep uses OpenAI tool format directly
+	ToolChoice       any            `json:"tool_choice,omitempty"` // Assuming Julep uses OpenAI format
+	// Add other Julep specific parameters if needed
+}
+
+// JulepChatResponse represents the non-streaming response from Julep's /chat endpoint
+type JulepChatResponse struct {
+	ID        string        `json:"id"` // Julep's own response ID (might differ from session ID)
+	CreatedAt time.Time     `json:"created_at"`
+	Choices   []JulepChoice `json:"choices"`
+	Usage     *JulepUsage   `json:"usage,omitempty"`
+	// Add other fields from Julep response
+}
+
+type JulepChoice struct {
+	Index        int          `json:"index"`
+	Message      JulepMessage `json:"message"`
+	FinishReason string       `json:"finish_reason"`
+}
+
+type JulepUsage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// --- Conversion Functions ---
+
+// convertOpenaiToJulep converts OpenAI request payload to Julep chat payload
+func convertOpenaiToJulep(openaiReq OpenAIRequest) JulepChatPayload {
+	julepMessages := make([]JulepMessage, len(openaiReq.Messages))
+	for i, msg := range openaiReq.Messages {
+		julepToolCalls := make([]JulepToolCall, len(msg.ToolCalls))
+		for j, tc := range msg.ToolCalls {
+			julepToolCalls[j] = JulepToolCall{
+				ID:   tc.ID,
+				Type: tc.Type,
+				Function: JulepFunction{ // Assuming only function type for now
+					Name:      tc.Function.Name,
+					Arguments: tc.Function.Arguments,
+				},
+			}
+		}
+		julepMessages[i] = JulepMessage{
+			Role:       msg.Role,
+			Content:    msg.Content,
+			Name:       msg.Name,
+			ToolCallID: msg.ToolCallID,
+			ToolCalls:  julepToolCalls,
+		}
+	}
+
+	payload := JulepChatPayload{
+		Messages:         julepMessages,
+		Model:            &openaiReq.Model, // Pass model if Julep expects it here
+		Stream:           false,            // Force false as Julep doesn't support streaming response
+		MaxTokens:        openaiReq.MaxTokens,
+		Temperature:      openaiReq.Temperature,
+		TopP:             openaiReq.TopP,
+		Stop:             openaiReq.Stop,
+		PresencePenalty:  openaiReq.PresencePenalty,
+		FrequencyPenalty: openaiReq.FrequencyPenalty,
+		Tools:            openaiReq.Tools,
+		ToolChoice:       openaiReq.ToolChoice,
+	}
+	// Clean up nil model pointer if model string is empty
+	if openaiReq.Model == "" {
+		payload.Model = nil
+	}
+	return payload
+}
+
+// convertJulepToOpenai converts Julep chat response to OpenAI response format
+// Takes sessionID to use it as the OpenAI response ID, as per JS example.
+func convertJulepToOpenai(julepResp *JulepChatResponse, modelName string, sessionID string) *OpenAIResponse {
+	openaiChoices := make([]OpenAIChoice, len(julepResp.Choices))
+	for i, choice := range julepResp.Choices {
+		openaiToolCalls := make([]OpenAIToolCall, len(choice.Message.ToolCalls))
+		for j, tc := range choice.Message.ToolCalls {
+			openaiToolCalls[j] = OpenAIToolCall{
+				ID:   tc.ID,
+				Type: tc.Type,
+				Function: OpenAIFunction{
+					Name:      tc.Function.Name,
+					Arguments: tc.Function.Arguments,
+				},
+			}
+		}
+		openaiChoices[i] = OpenAIChoice{
+			Index: choice.Index,
+			Message: OpenAIMessage{
+				Role:      choice.Message.Role,
+				Content:   choice.Message.Content,
+				ToolCalls: openaiToolCalls,
+			},
+			FinishReason: choice.FinishReason,
+		}
+	}
+
+	var openaiUsage *OpenAIUsage
+	if julepResp.Usage != nil {
+		openaiUsage = &OpenAIUsage{
+			PromptTokens:     julepResp.Usage.PromptTokens,
+			CompletionTokens: julepResp.Usage.CompletionTokens,
+			TotalTokens:      julepResp.Usage.TotalTokens,
+		}
+	}
+
+	return &OpenAIResponse{
+		ID:      sessionID, // Use the generated Session ID as OpenAI ID
+		Object:  "chat.completion",
+		Created: julepResp.CreatedAt.Unix(),
+		Model:   modelName, // Use the model requested by the client
+		Choices: openaiChoices,
+		Usage:   openaiUsage,
+	}
+}
+
+// --- API Call Functions ---
+
+// makeJulepRequest performs the actual HTTP request to a Julep endpoint.
+// It handles request creation, sending, and basic response/error handling.
+func makeJulepRequest(ctx context.Context, logger *slog.Logger, method, url string, headers http.Header, requestBody any, responseTarget any, reqID string) (int, error) {
+	logAttrs := []any{"request_id", reqID, "method", method, "url", url}
+	logger.Debug("Making Julep API request...", logAttrs...)
+
+	var reqBodyReader io.Reader
+	if requestBody != nil {
+		jsonBody, err := json.Marshal(requestBody)
+		if err != nil {
+			logger.Error("Failed to marshal Julep request body", append(logAttrs, "error", err)...)
+			return 0, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		reqBodyReader = bytes.NewBuffer(jsonBody)
+		logAttrs = append(logAttrs, "body_size", len(jsonBody)) // Log body size
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, method, url, reqBodyReader)
+	if err != nil {
+		logger.Error("Failed to create Julep HTTP request", append(logAttrs, "error", err)...)
+		return 0, fmt.Errorf("failed to create HTTP request: %w", err)
+	}
+
+	// Copy essential headers (Authorization, Content-Type if body exists)
+	// Avoid copying Host, Content-Length etc.
+	if auth := headers.Get("Authorization"); auth != "" {
+		httpReq.Header.Set("Authorization", auth)
+	}
+	// Only set Content-Type if we have a body
+	if requestBody != nil {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	// Add other necessary headers if Julep requires them
+
+	startTime := time.Now()
+	httpResp, err := apiClient.Do(httpReq)
+	duration := time.Since(startTime)
+	logAttrs = append(logAttrs, "duration_ms", duration.Milliseconds())
+
+	if err != nil {
+		// Handle context deadline exceeded specifically
+		if errors.Is(err, context.DeadlineExceeded) {
+			logger.Error("Julep API request timed out", append(logAttrs, "error", err)...)
+			return http.StatusGatewayTimeout, fmt.Errorf("request to %s timed out: %w", url, err)
+		}
+		logger.Error("Julep API request failed", append(logAttrs, "error", err)...)
+		return 0, fmt.Errorf("failed to send request to %s: %w", url, err)
+	}
+	defer httpResp.Body.Close()
+
+	logAttrs = append(logAttrs, "status_code", httpResp.StatusCode)
+
+	// Read the body regardless of status code for potential error messages
+	respBodyBytes, readErr := io.ReadAll(httpResp.Body)
+	if readErr != nil {
+		logger.Warn("Failed to read Julep response body", append(logAttrs, "read_error", readErr)...)
+		// Continue processing status code error if possible
+	} else {
+		logAttrs = append(logAttrs, "response_size", len(respBodyBytes))
+		// Log trimmed response body for debugging (be careful with sensitive data)
+		// logger.Debug("Julep response body", append(logAttrs, "body", string(respBodyBytes))...)
+	}
+
+	// Check for non-successful status codes
+	if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
+		errMsg := fmt.Sprintf("Julep API returned error status %d", httpResp.StatusCode)
+		if len(respBodyBytes) > 0 {
+			errMsg = fmt.Sprintf("%s: %s", errMsg, string(respBodyBytes))
+		}
+		logger.Error("Julep API request returned non-2xx status", logAttrs...)
+		// Return the status code and an error containing the message
+		return httpResp.StatusCode, fmt.Errorf(errMsg)
+	}
+
+	// If successful and a response target is provided, decode the body
+	if responseTarget != nil && len(respBodyBytes) > 0 {
+		if err := json.Unmarshal(respBodyBytes, responseTarget); err != nil {
+			logger.Error("Failed to unmarshal Julep response body", append(logAttrs, "error", err, "body_preview", string(respBodyBytes[:min(len(respBodyBytes), 100)]))...)
+			return httpResp.StatusCode, fmt.Errorf("failed to decode Julep response: %w", err)
+		}
+		logger.Debug("Successfully decoded Julep response", logAttrs...)
+	} else {
+		logger.Debug("Julep request successful, no response body expected or decoded.", logAttrs...)
+	}
+
+	return httpResp.StatusCode, nil
+}
+
+// callJulepChat orchestrates the calls to Julep: create agent, create session, then chat.
+func callJulepChat(ctx context.Context, logger *slog.Logger, headers http.Header, openaiReq OpenAIRequest, requestID string) (*OpenAIResponse, int, error) {
+	reqLogger := logger.With("request_id", requestID)
+
+	// --- 1. Create Agent ---
+	agentID := generateUUID()
+	agentURL := fmt.Sprintf("%s/agents/%s", JulepApiBaseURL, agentID)
+	agentPayload := CreateAgentPayload{
+		Name:  fmt.Sprintf("temp-agent-%s", agentID),
+		About: "Temporary agent created for a chat session via proxy.",
+	}
+	reqLogger.Info("Creating temporary Julep agent", "agent_id", agentID)
+	statusCode, err := makeJulepRequest(ctx, reqLogger, http.MethodPost, agentURL, headers, agentPayload, nil, requestID) // No response body needed for agent creation? Adjust if needed.
+	if err != nil {
+		reqLogger.Error("Failed to create Julep agent", "error", err, "status_code", statusCode)
+		// Map status code for client response
+		if statusCode == 0 || statusCode >= 500 {
+			return nil, http.StatusBadGateway, fmt.Errorf("failed to initialize session (agent creation failed): %w", err)
+		}
+		return nil, statusCode, fmt.Errorf("failed to create agent: %w", err) // Propagate client-side errors if needed
+	}
+	reqLogger.Info("Julep agent created successfully", "agent_id", agentID)
+
+	// --- 2. Create Session ---
+	sessionID := generateUUID() // Julep uses UUID in path, so generate one here
+	sessionURL := fmt.Sprintf("%s/sessions/%s", JulepApiBaseURL, sessionID)
+	sessionPayload := CreateSessionPayload{
+		AgentID: agentID, // Link to the created agent
+	}
+	reqLogger.Info("Creating temporary Julep session", "session_id", sessionID, "linked_agent_id", agentID)
+	statusCode, err = makeJulepRequest(ctx, reqLogger, http.MethodPost, sessionURL, headers, sessionPayload, nil, requestID) // No response body needed? Adjust if needed.
+	if err != nil {
+		reqLogger.Error("Failed to create Julep session", "error", err, "status_code", statusCode)
+		// Maybe cleanup agent here if session fails? Omitted for simplicity.
+		if statusCode == 0 || statusCode >= 500 {
+			return nil, http.StatusBadGateway, fmt.Errorf("failed to initialize session (session creation failed): %w", err)
+		}
+		return nil, statusCode, fmt.Errorf("failed to create session: %w", err)
+	}
+	reqLogger.Info("Julep session created successfully", "session_id", sessionID)
+
+	// --- 3. Call Chat Endpoint ---
+	chatURL := fmt.Sprintf("%s/sessions/%s/chat", JulepApiBaseURL, sessionID)
+	julepPayload := convertOpenaiToJulep(openaiReq)
+	reqLogger.Info("Calling Julep chat endpoint", "url", chatURL)
+
+	// Use a longer timeout context specifically for the chat call if needed
+	chatCtx := ctx                    // Use original context by default
+	if _, ok := ctx.Deadline(); !ok { // If no deadline set on original context, apply chat timeout
+		var cancel context.CancelFunc
+		chatCtx, cancel = context.WithTimeout(context.Background(), chatTimeout)
+		defer cancel()
+		reqLogger.Debug("Applying specific timeout for chat request", "timeout", chatTimeout)
+	}
+
+	var julepResponse JulepChatResponse
+	statusCode, err = makeJulepRequest(chatCtx, reqLogger, http.MethodPost, chatURL, headers, julepPayload, &julepResponse, requestID)
+	if err != nil {
+		reqLogger.Error("Julep chat request failed", "error", err, "status_code", statusCode)
+		// Map Julep error status codes to appropriate client responses
+		if statusCode == 0 || statusCode >= 500 || statusCode == http.StatusGatewayTimeout || statusCode == http.StatusServiceUnavailable {
+			return nil, http.StatusBadGateway, fmt.Errorf("upstream API error during chat: %w", err)
+		}
+		// Propagate other errors (e.g., 4xx from Julep)
+		return nil, statusCode, fmt.Errorf("julep chat API error: %w", err)
+	}
+	reqLogger.Info("Julep chat request successful")
+
+	// --- 4. Convert Julep Response to OpenAI Response ---
+	openaiResponse := convertJulepToOpenai(&julepResponse, openaiReq.Model, sessionID)
+
+	// Optional: Consider deleting the temporary agent/session here
+	// reqLogger.Info("Skipping temporary agent/session cleanup for now.")
+
+	// Return the converted response, final status (OK), and no error
+	return openaiResponse, http.StatusOK, nil
+}
+
+// Helper for logging byte slices
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

utils.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+// writeJSONError sends a standard JSON error response.
+func writeJSONError(w http.ResponseWriter, logger *slog.Logger, statusCode int, message string, errType *string, errCode *string, param *string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	resp := ErrorResponse{
+		Error: APIError{
+			Message: message,
+			Type:    errType,
+			Code:    errCode,
+			Param:   param,
+		},
+	}
+	if err := json.NewEncoder(w).Encode(resp); err != nil {
+		// If encoding fails, log it but we can't send another response
+		logger.Error("Failed to encode error response", "error", err)
+	}
+}
+
+// generateUUID creates a new UUID string.
+func generateUUID() string {
+	return uuid.NewString()
+}
+
+// Helper function to get string pointer
+func stringPtr(s string) *string {
+	if s == "" {
+		return nil // Don't return pointer to empty string unless intended
+	}
+	return &s
+}