Add native function calling and agentic loop for all models

Refactor main.go to implement native function calling for all models, introduce an agentic loop for tools with `x-endpoint`, and support both streaming and non-streaming responses.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: a225ab96-d6aa-42ce-a50b-aa844bc8db2b
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: 89abe5cc-56f8-4be5-8720-0ed0d1873457
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/cbd1ae84-d682-4025-b26d-c56df1ac13a1/a225ab96-d6aa-42ce-a50b-aa844bc8db2b/jm4hNZf
Replit-Helium-Checkpoint-Created: true

.replit

@@ -30,13 +30,13 @@ args = "Start application"
 name = "Start application"
 author = "agent"
 
+[workflows.workflow.metadata]
+outputType = "console"
+
 [[workflows.workflow.tasks]]
 task = "shell.exec"
 args = "go run ."
-waitForPort = 8080
-
-[workflows.workflow.metadata]
-outputType = "console"
+waitForPort = 3000
 
 [agent]
 stack = "PNPM_WORKSPACE"

main.go

@@ -5,18 +5,20 @@ import (
         "bytes"
         "encoding/json"
         "fmt"
+        "io"
         "log"
         "net/http"
         "os"
         "sort"
         "strings"
+        "time"
 )
 
 const (
-        NvidiaBaseURL = "https://integrate.api.nvidia.com/v1"
-        // Hardcodowany klucz
-        NvidiaAPIKey  = "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"
-        GatewayAPIKey = "connect"
+        NvidiaBaseURL     = "https://integrate.api.nvidia.com/v1"
+        NvidiaAPIKey      = "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"
+        GatewayAPIKey     = "connect"
+        MaxToolIterations = 10
 )
 
 var modelAliases = map[string]string{
@@ -37,11 +39,23 @@ type Message struct {
         Name       string      `json:"name,omitempty"`
 }
 
+type ToolFunction struct {
+        Name        string                 `json:"name"`
+        Description string                 `json:"description,omitempty"`
+        Parameters  map[string]interface{} `json:"parameters,omitempty"`
+        Endpoint    string                 `json:"x-endpoint,omitempty"`
+}
+
+type Tool struct {
+        Type     string       `json:"type"`
+        Function ToolFunction `json:"function"`
+}
+
 type ChatRequest struct {
         Model       string        `json:"model"`
         Messages    []Message     `json:"messages"`
         Stream      *bool         `json:"stream,omitempty"`
-        Tools       []interface{} `json:"tools,omitempty"`
+        Tools       []Tool        `json:"tools,omitempty"`
         ToolChoice  interface{}   `json:"tool_choice,omitempty"`
         Temperature *float64      `json:"temperature,omitempty"`
         MaxTokens   *int          `json:"max_tokens,omitempty"`
@@ -54,63 +68,132 @@ type AccumToolCall struct {
         Args  string
 }
 
-// --- LOGIKA ---
+// --- POMOCNICZE ---
 
 func resolveModel(requested string) string {
-        if full, ok := modelAliases[requested]; ok { return full }
+        if full, ok := modelAliases[requested]; ok {
+                return full
+        }
         return requested
 }
 
 func injectSystemPrompt(messages []Message, modelID string) []Message {
         prompt, ok := systemPrompts[modelID]
-        if !ok || prompt == "" { return messages }
-        if len(messages) > 0 && messages[0].Role == "system" { return messages }
+        if !ok || prompt == "" {
+                return messages
+        }
+        if len(messages) > 0 && messages[0].Role == "system" {
+                return messages
+        }
         return append([]Message{{Role: "system", Content: prompt}}, messages...)
 }
 
-func handleChat(w http.ResponseWriter, r *http.Request) {
-        if r.Method == http.MethodOptions {
-                w.Header().Set("Access-Control-Allow-Origin", "*")
-                w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
-                w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key")
-                w.WriteHeader(http.StatusNoContent)
-                return
+func findTool(tools []Tool, name string) *Tool {
+        for _, t := range tools {
+                if t.Function.Name == name {
+                        return &t
+                }
         }
+        return nil
+}
 
-        auth := r.Header.Get("Authorization")
-        if !strings.Contains(auth, GatewayAPIKey) && r.Header.Get("x-api-key") != GatewayAPIKey {
-                http.Error(w, "Unauthorized", http.StatusUnauthorized); return
+// executeToolCall wykonuje HTTP POST do x-endpoint narzędzia
+func executeToolCall(tool *Tool, argsJSON string) string {
+        if tool == nil || tool.Function.Endpoint == "" {
+                return fmt.Sprintf(`{"error":"brak x-endpoint dla narzędzia %s"}`, tool.Function.Name)
         }
 
-        var req ChatRequest
-        json.NewDecoder(r.Body).Decode(&req)
+        var args interface{}
+        json.Unmarshal([]byte(argsJSON), &args)
+        body, _ := json.Marshal(args)
 
-        modelID := resolveModel(req.Model)
-        upstreamPayload := map[string]interface{}{
+        client := &http.Client{Timeout: 30 * time.Second}
+        resp, err := client.Post(tool.Function.Endpoint, "application/json", bytes.NewReader(body))
+        if err != nil {
+                return fmt.Sprintf(`{"error":"%s"}`, err.Error())
+        }
+        defer resp.Body.Close()
+        result, _ := io.ReadAll(resp.Body)
+        return string(result)
+}
+
+// --- UPSTREAM CALL (non-streaming, zbiera pełną odpowiedź) ---
+
+func callUpstream(modelID string, messages []Message, tools []Tool, toolChoice interface{}, temperature *float64, maxTokens *int) (map[string]interface{}, error) {
+        payload := map[string]interface{}{
                 "model":    modelID,
-                "messages": injectSystemPrompt(req.Messages, modelID),
+                "messages": messages,
+                "stream":   false,
+        }
+        if temperature != nil {
+                payload["temperature"] = *temperature
+        }
+        if maxTokens != nil {
+                payload["max_tokens"] = *maxTokens
+        }
+        if len(tools) > 0 {
+                payload["tools"] = tools
+                if toolChoice != nil {
+                        payload["tool_choice"] = toolChoice
+                } else {
+                        payload["tool_choice"] = "auto"
+                }
+        }
+
+        body, _ := json.Marshal(payload)
+        req, _ := http.NewRequest("POST", NvidiaBaseURL+"/chat/completions", bytes.NewReader(body))
+        req.Header.Set("Content-Type", "application/json")
+        req.Header.Set("Authorization", "Bearer "+NvidiaAPIKey)
+
+        client := &http.Client{Timeout: 120 * time.Second}
+        resp, err := client.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+
+        var result map[string]interface{}
+        if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+                return nil, err
+        }
+        return result, nil
+}
+
+// --- STREAMING UPSTREAM (ostatnia odpowiedź) ---
+
+func streamUpstream(w http.ResponseWriter, modelID string, messages []Message, tools []Tool, toolChoice interface{}, temperature *float64, maxTokens *int, clientModel string) {
+        payload := map[string]interface{}{
+                "model":    modelID,
+                "messages": messages,
                 "stream":   true,
         }
-        if req.Temperature != nil { upstreamPayload["temperature"] = *req.Temperature }
-        if req.MaxTokens != nil { upstreamPayload["max_tokens"] = *req.MaxTokens }
-        if len(req.Tools) > 0 {
-                upstreamPayload["tools"] = req.Tools
-                upstreamPayload["tool_choice"] = req.ToolChoice
+        if temperature != nil {
+                payload["temperature"] = *temperature
+        }
+        if maxTokens != nil {
+                payload["max_tokens"] = *maxTokens
+        }
+        if len(tools) > 0 {
+                payload["tools"] = tools
+                if toolChoice != nil {
+                        payload["tool_choice"] = toolChoice
+                } else {
+                        payload["tool_choice"] = "auto"
+                }
         }
 
-        body, _ := json.Marshal(upstreamPayload)
-        upstreamReq, _ := http.NewRequest("POST", NvidiaBaseURL+"/chat/completions", bytes.NewReader(body))
-        upstreamReq.Header.Set("Content-Type", "application/json")
-        upstreamReq.Header.Set("Authorization", "Bearer "+NvidiaAPIKey)
+        body, _ := json.Marshal(payload)
+        req, _ := http.NewRequest("POST", NvidiaBaseURL+"/chat/completions", bytes.NewReader(body))
+        req.Header.Set("Content-Type", "application/json")
+        req.Header.Set("Authorization", "Bearer "+NvidiaAPIKey)
 
-        resp, err := http.DefaultClient.Do(upstreamReq)
-        if err != nil { http.Error(w, err.Error(), 502); return }
+        resp, err := http.DefaultClient.Do(req)
+        if err != nil {
+                http.Error(w, err.Error(), 502)
+                return
+        }
         defer resp.Body.Close()
 
-        w.Header().Set("Content-Type", "text/event-stream")
-        w.Header().Set("Access-Control-Allow-Origin", "*")
-        w.Header().Set("X-Accel-Buffering", "no")
-        
         flusher, _ := w.(http.Flusher)
         scanner := bufio.NewScanner(resp.Body)
         accum := make(map[int]*AccumToolCall)
@@ -119,19 +202,28 @@ func handleChat(w http.ResponseWriter, r *http.Request) {
         for scanner.Scan() {
                 line := scanner.Text()
                 if !strings.HasPrefix(line, "data: ") || line == "data: [DONE]" {
-                        fmt.Fprint(w, line+"\n\n"); if flusher != nil { flusher.Flush() }; continue
+                        fmt.Fprint(w, line+"\n\n")
+                        if flusher != nil {
+                                flusher.Flush()
+                        }
+                        continue
                 }
 
                 var chunk map[string]interface{}
                 if err := json.Unmarshal([]byte(strings.TrimPrefix(line, "data: ")), &chunk); err != nil {
                         continue
                 }
-                
+
                 choices, ok := chunk["choices"].([]interface{})
-                if !ok || len(choices) == 0 { continue }
-                
+                if !ok || len(choices) == 0 {
+                        continue
+                }
+
                 choice := choices[0].(map[string]interface{})
-                delta := choice["delta"].(map[string]interface{})
+                delta, _ := choice["delta"].(map[string]interface{})
+                if delta == nil {
+                        continue
+                }
                 finishReason := choice["finish_reason"]
 
                 if tcs, ok := delta["tool_calls"].([]interface{}); ok {
@@ -141,12 +233,18 @@ func handleChat(w http.ResponseWriter, r *http.Request) {
                                 acc, exists := accum[idx]
                                 if !exists {
                                         acc = &AccumToolCall{Index: idx}
-                                        if id, ok := tc["id"].(string); ok { acc.ID = id }
+                                        if id, ok := tc["id"].(string); ok {
+                                                acc.ID = id
+                                        }
                                         accum[idx] = acc
                                 }
                                 if fn, ok := tc["function"].(map[string]interface{}); ok {
-                                        if name, ok := fn["name"].(string); ok { acc.Name += name }
-                                        if args, ok := fn["arguments"].(string); ok { acc.Args += args }
+                                        if name, ok := fn["name"].(string); ok {
+                                                acc.Name += name
+                                        }
+                                        if args, ok := fn["arguments"].(string); ok {
+                                                acc.Args += args
+                                        }
                                 }
                         }
                         continue
@@ -154,7 +252,9 @@ func handleChat(w http.ResponseWriter, r *http.Request) {
 
                 if (finishReason == "tool_calls" || finishReason == "function_call") && len(accum) > 0 {
                         var keys []int
-                        for k := range accum { keys = append(keys, k) }
+                        for k := range accum {
+                                keys = append(keys, k)
+                        }
                         sort.Ints(keys)
 
                         finalTools := []map[string]interface{}{}
@@ -168,16 +268,18 @@ func handleChat(w http.ResponseWriter, r *http.Request) {
 
                         response := map[string]interface{}{
                                 "id": chunk["id"], "object": "chat.completion.chunk", "created": chunk["created"],
-                                "model": req.Model,
+                                "model": clientModel,
                                 "choices": []map[string]interface{}{{
-                                        "index": 0,
-                                        "delta": map[string]interface{}{"role": "assistant", "tool_calls": finalTools},
+                                        "index":         0,
+                                        "delta":         map[string]interface{}{"role": "assistant", "tool_calls": finalTools},
                                         "finish_reason": "tool_calls",
                                 }},
                         }
                         jsonBytes, _ := json.Marshal(response)
                         fmt.Fprintf(w, "data: %s\n\n", string(jsonBytes))
-                        if flusher != nil { flusher.Flush() }
+                        if flusher != nil {
+                                flusher.Flush()
+                        }
                         accum = make(map[int]*AccumToolCall)
                         continue
                 }
@@ -186,23 +288,189 @@ func handleChat(w http.ResponseWriter, r *http.Request) {
                         delta["role"] = "assistant"
                         firstChunkSent = true
                 }
-                
+
                 if delta["content"] == nil && delta["tool_calls"] == nil && finishReason == nil {
                         continue
                 }
 
+                // podmień model na alias klienta
+                chunk["model"] = clientModel
                 out, _ := json.Marshal(chunk)
                 fmt.Fprintf(w, "data: %s\n\n", string(out))
-                if flusher != nil { flusher.Flush() }
+                if flusher != nil {
+                        flusher.Flush()
+                }
+        }
+
+        fmt.Fprint(w, "data: [DONE]\n\n")
+        if flusher != nil {
+                flusher.Flush()
         }
 }
 
+// --- GŁÓWNY HANDLER ---
+
+func handleChat(w http.ResponseWriter, r *http.Request) {
+        if r.Method == http.MethodOptions {
+                w.Header().Set("Access-Control-Allow-Origin", "*")
+                w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
+                w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key")
+                w.WriteHeader(http.StatusNoContent)
+                return
+        }
+
+        auth := r.Header.Get("Authorization")
+        if !strings.Contains(auth, GatewayAPIKey) && r.Header.Get("x-api-key") != GatewayAPIKey {
+                http.Error(w, "Unauthorized", http.StatusUnauthorized)
+                return
+        }
+
+        var req ChatRequest
+        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+                http.Error(w, "Bad Request", http.StatusBadRequest)
+                return
+        }
+
+        clientModel := req.Model
+        modelID := resolveModel(req.Model)
+        messages := injectSystemPrompt(req.Messages, modelID)
+        tools := req.Tools
+        toolChoice := req.ToolChoice
+
+        wantStream := req.Stream == nil || *req.Stream
+
+        // --- PĘTLA AGENTYCZNA ---
+        // Jeśli są narzędzia z x-endpoint, automatycznie wykonujemy pętle tool calls.
+        // Każda iteracja: non-streaming call → sprawdź tool_calls → wykonaj → dodaj wyniki → powtórz.
+        // Ostatnia odpowiedź (bez tool_calls) jest streamowana/zwracana do klienta.
+
+        hasAutoExec := false
+        if len(tools) > 0 {
+                for _, t := range tools {
+                        if t.Function.Endpoint != "" {
+                                hasAutoExec = true
+                                break
+                        }
+                }
+        }
+
+        if hasAutoExec {
+                for i := 0; i < MaxToolIterations; i++ {
+                        result, err := callUpstream(modelID, messages, tools, toolChoice, req.Temperature, req.MaxTokens)
+                        if err != nil {
+                                http.Error(w, err.Error(), 502)
+                                return
+                        }
+
+                        choices, ok := result["choices"].([]interface{})
+                        if !ok || len(choices) == 0 {
+                                break
+                        }
+
+                        choice := choices[0].(map[string]interface{})
+                        message, _ := choice["message"].(map[string]interface{})
+                        finishReason, _ := choice["finish_reason"].(string)
+
+                        // dodaj wiadomość asystenta do historii
+                        assistantMsg := Message{Role: "assistant"}
+                        if content, ok := message["content"]; ok && content != nil {
+                                assistantMsg.Content = content
+                        }
+                        if tcs, ok := message["tool_calls"]; ok && tcs != nil {
+                                assistantMsg.ToolCalls = tcs
+                        }
+                        messages = append(messages, assistantMsg)
+
+                        if finishReason != "tool_calls" && finishReason != "function_call" {
+                                // brak tool calls — zwróć wynik klientowi
+                                w.Header().Set("Content-Type", "application/json")
+                                w.Header().Set("Access-Control-Allow-Origin", "*")
+                                result["model"] = clientModel
+                                json.NewEncoder(w).Encode(result)
+                                return
+                        }
+
+                        // wykonaj wszystkie tool calls
+                        tcList, _ := message["tool_calls"].([]interface{})
+                        for _, tcVal := range tcList {
+                                tc, _ := tcVal.(map[string]interface{})
+                                if tc == nil {
+                                        continue
+                                }
+                                tcID, _ := tc["id"].(string)
+                                fn, _ := tc["function"].(map[string]interface{})
+                                if fn == nil {
+                                        continue
+                                }
+                                fnName, _ := fn["name"].(string)
+                                fnArgs, _ := fn["arguments"].(string)
+
+                                tool := findTool(tools, fnName)
+                                toolResult := executeToolCall(tool, fnArgs)
+
+                                messages = append(messages, Message{
+                                        Role:       "tool",
+                                        Content:    toolResult,
+                                        ToolCallID: tcID,
+                                        Name:       fnName,
+                                })
+                        }
+                }
+
+                // max iteracji osiągnięte — ostatnia próba bez narzędzi
+                result, err := callUpstream(modelID, messages, nil, nil, req.Temperature, req.MaxTokens)
+                if err != nil {
+                        http.Error(w, err.Error(), 502)
+                        return
+                }
+                w.Header().Set("Content-Type", "application/json")
+                w.Header().Set("Access-Control-Allow-Origin", "*")
+                result["model"] = clientModel
+                json.NewEncoder(w).Encode(result)
+                return
+        }
+
+        // --- NORMALNY TRYB (bez auto-exec): stream do klienta ---
+        w.Header().Set("Content-Type", "text/event-stream")
+        w.Header().Set("Access-Control-Allow-Origin", "*")
+        w.Header().Set("X-Accel-Buffering", "no")
+        w.Header().Set("Cache-Control", "no-cache")
+
+        if !wantStream {
+                // klient nie chce streamu — zbierz odpowiedź i zwróć JSON
+                result, err := callUpstream(modelID, messages, tools, toolChoice, req.Temperature, req.MaxTokens)
+                if err != nil {
+                        http.Error(w, err.Error(), 502)
+                        return
+                }
+                w.Header().Set("Content-Type", "application/json")
+                result["model"] = clientModel
+                json.NewEncoder(w).Encode(result)
+                return
+        }
+
+        streamUpstream(w, modelID, messages, tools, toolChoice, req.Temperature, req.MaxTokens, clientModel)
+}
+
 func handleModels(w http.ResponseWriter, r *http.Request) {
+        if r.Method == http.MethodOptions {
+                w.Header().Set("Access-Control-Allow-Origin", "*")
+                w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+                w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key")
+                w.WriteHeader(http.StatusNoContent)
+                return
+        }
         w.Header().Set("Content-Type", "application/json")
         w.Header().Set("Access-Control-Allow-Origin", "*")
         var data []map[string]interface{}
+        now := time.Now().Unix()
         for alias := range modelAliases {
-                data = append(data, map[string]interface{}{"id": alias, "object": "model", "owned_by": "nvidia"})
+                data = append(data, map[string]interface{}{
+                        "id":       alias,
+                        "object":   "model",
+                        "created":  now,
+                        "owned_by": "nvidia",
+                })
         }
         json.NewEncoder(w).Encode(map[string]interface{}{"object": "list", "data": data})
 }
@@ -210,11 +478,13 @@ func handleModels(w http.ResponseWriter, r *http.Request) {
 func main() {
         port := os.Getenv("PORT")
         if port == "" {
-                port = "8080"
+                port = "3000"
         }
         mux := http.NewServeMux()
         mux.HandleFunc("/v1/chat/completions", handleChat)
         mux.HandleFunc("/v1/models", handleModels)
         log.Printf("Gateway running on :%s", port)
-        http.ListenAndServe(":"+port, mux)
+        if err := http.ListenAndServe(":"+port, mux); err != nil {
+                log.Fatalf("Server error: %v", err)
+        }
 }