├── .gitignore
├── internal
    └── pkg
    │   ├── web
    │       ├── headers.go
    │       ├── handler.go
    │       ├── response.go
    │       ├── templates.go
    │       └── web.go
    │   ├── websocketServer
    │       ├── websocketServer.go
    │       └── websocketServerImpl.go
    │   ├── chatSession
    │       ├── chatSession.go
    │       ├── chatSessionImpl.go
    │       └── agentChatSession.go
    │   ├── staticAssets
    │       └── handler.go
    │   ├── cookies
    │       ├── helpers.go
    │       ├── cookies.go
    │       └── cookies_test.go
    │   ├── sessions
    │       └── sessions.go
    │   ├── httpHandlers
    │       ├── uiTypes.go
    │       └── chatHandlers.go
    │   ├── config
    │       └── config.go
    │   ├── models
    │       ├── providers.go
    │       └── gemini
    │       │   └── gemini.go
    │   ├── mcpConfig
    │       └── config.go
    │   ├── agent
    │       └── agent.go
    │   └── tools
    │       └── mcp.go
├── web
    ├── templates
    │   ├── chat-messages.gohtml
    │   ├── chat-message.gohtml
    │   ├── chat-response.gohtml
    │   └── main.gohtml
    ├── frontend
    │   ├── public
    │   │   ├── logo.png
    │   │   └── logo-s.png
    │   ├── htmx.js
    │   ├── style.css
    │   ├── .gitignore
    │   ├── vite.config.js
    │   ├── css
    │   │   ├── header.css
    │   │   ├── footer.css
    │   │   ├── body.css
    │   │   ├── button.css
    │   │   ├── content.css
    │   │   └── loader.css
    │   ├── package.json
    │   ├── index.html
    │   └── main.js
    └── embed.go
├── configs
    └── mcp.config.json
├── cmd
    ├── calculator
    │   ├── applicationConfig.go
    │   └── main.go
    ├── ricky-bot
    │   ├── applicationConfig.go
    │   └── main.go
    └── calculator-mcp
    │   ├── README.md
    │   └── main.go
├── README.md
├── justfile
├── go.mod
├── docs
    └── architecture.md
└── go.sum


/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea
2 | /ricky-bot*
3 | /calculator*
4 | 


--------------------------------------------------------------------------------
/internal/pkg/web/headers.go:
--------------------------------------------------------------------------------
1 | package web
2 | 
3 | type Headers map[string]string
4 | 


--------------------------------------------------------------------------------
/web/templates/chat-messages.gohtml:
--------------------------------------------------------------------------------
1 | {{range .}}
2 |   {{template "chat-message.gohtml" .}}
3 | {{end}}


--------------------------------------------------------------------------------
/web/frontend/public/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apis/ai-chat/master/web/frontend/public/logo.png


--------------------------------------------------------------------------------
/web/frontend/public/logo-s.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apis/ai-chat/master/web/frontend/public/logo-s.png


--------------------------------------------------------------------------------
/configs/mcp.config.json:
--------------------------------------------------------------------------------
1 | {
2 |   "mcpServers": {
3 |     "calculator": {
4 |       "command": "/home/apis/sandbox/ai-chat/calculator-mcp",
5 |       "args": []
6 |     }
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/web/embed.go:
--------------------------------------------------------------------------------
 1 | package web
 2 | 
 3 | import "embed"
 4 | 
 5 | var (
 6 | 	//go:embed templates
 7 | 	TemplateFS embed.FS
 8 | 
 9 | 	//go:embed frontend/dist
10 | 	EmbedFs embed.FS
11 | )
12 | 


--------------------------------------------------------------------------------
/web/frontend/htmx.js:
--------------------------------------------------------------------------------
1 | // Workaround to enable HTMX extensions support with Vite, see https://github.com/bigskysoftware/htmx/issues/1690
2 | 
3 | import htmx from 'htmx.org'
4 | window.htmx = htmx


--------------------------------------------------------------------------------
/web/frontend/style.css:
--------------------------------------------------------------------------------
1 | @import "css/body.css";
2 | @import "css/loader.css";
3 | @import "css/button.css";
4 | @import "css/header.css";
5 | @import "css/content.css";
6 | @import "css/footer.css";
7 | 


--------------------------------------------------------------------------------
/cmd/calculator/applicationConfig.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | type applicationConfig struct {
4 | 	Host string `config_default:"localhost" config_description:"Server host interface"`
5 | 	Port int    `config_default:"8081" config_description:"Server port"`
6 | }
7 | 


--------------------------------------------------------------------------------
/internal/pkg/websocketServer/websocketServer.go:
--------------------------------------------------------------------------------
 1 | package websocketServer
 2 | 
 3 | import (
 4 | 	"github.com/google/uuid"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type WebsocketServer interface {
 9 | 	Handler(responseWriter http.ResponseWriter, request *http.Request)
10 | 	Publish(id uuid.UUID, message []byte)
11 | }
12 | 


--------------------------------------------------------------------------------
/web/templates/chat-message.gohtml:
--------------------------------------------------------------------------------
 1 | <div class="chat-message user">
 2 |     <div class="raw">
 3 |         {{.UserMessageContent}}
 4 |     </div>
 5 |     <div class="formatted"></div>
 6 | </div>
 7 | 
 8 | <div class="chat-message assistant">
 9 |     <div class="raw">
10 |         {{.AssistantMessageContent}}
11 |     </div>
12 |     <div class="formatted"></div>
13 | </div>


--------------------------------------------------------------------------------
/web/frontend/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | pnpm-debug.log*
 8 | lerna-debug.log*
 9 | 
10 | node_modules
11 | dist
12 | dist-ssr
13 | *.local
14 | 
15 | # Editor directories and files
16 | .vscode/*
17 | !.vscode/extensions.json
18 | .idea
19 | .DS_Store
20 | *.suo
21 | *.ntvs*
22 | *.njsproj
23 | *.sln
24 | *.sw?
25 | 


--------------------------------------------------------------------------------
/internal/pkg/web/handler.go:
--------------------------------------------------------------------------------
 1 | package web
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type Handler struct {
 8 | 	Request        func(request *http.Request, simulatedDelay int) *Response
 9 | 	SimulatedDelay int
10 | }
11 | 
12 | func (instance Handler) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
13 | 	response := instance.Request(request, instance.SimulatedDelay)
14 | 	response.Write(responseWriter)
15 | }
16 | 


--------------------------------------------------------------------------------
/web/frontend/vite.config.js:
--------------------------------------------------------------------------------
 1 | import cssnano from "cssnano"
 2 | import postcssImport from "postcss-import"
 3 | import postcssInherit from "postcss-inherit"
 4 | 
 5 | 
 6 | export default {
 7 |     base: "/chat",
 8 |     css: {
 9 |         postcss: {
10 |             plugins: [
11 |                 cssnano({preset: "default"}),
12 |                 postcssImport(),
13 |                 postcssInherit(),
14 |             ],
15 |         }
16 |     },
17 | }


--------------------------------------------------------------------------------
/internal/pkg/chatSession/chatSession.go:
--------------------------------------------------------------------------------
 1 | package chatSession
 2 | 
 3 | type ChatBlockResponse struct {
 4 | 	ChatBlock ChatBlock
 5 | 	New       bool
 6 | }
 7 | 
 8 | type ChatBlock struct {
 9 | 	SystemMessage    string
10 | 	UserMessage      string
11 | 	AssistantMessage string
12 | 	Completed        bool
13 | 	Failed           bool
14 | }
15 | 
16 | type ChatSession interface {
17 | 	EnqueueMessage(message string) error
18 | 	Shutdown()
19 | 	ChatBlocks() []ChatBlock
20 | }
21 | 
22 | type ChatBlockResponseFunc func(response ChatBlockResponse)
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # AI Chat Project
 2 | 
 3 | #### TODO items
 4 | 
 5 | * Tools integration
 6 | * Sessions type locking
 7 | * Session timeout and scheduled cleanup
 8 | * Websocket behavior after time out
 9 | * Incremental update from server
10 | * Disable controls when server is answering
11 | * Cancel answer button
12 | * "Answering" UI spinner
13 | * Format user input as text - preserve new lines / spaces
14 | 
15 | 
16 | curl -LsSf https://astral.sh/uv/install.sh | sh
17 | 
18 | mcphost -m ollama:granite3.3:8b --config "./configs/mcphost.config.json"
19 | 
20 | ./mcphost -m "ollama:qwen3:8b" --config "../ai-chat/configs/mcphost.config.json"


--------------------------------------------------------------------------------
/web/frontend/css/header.css:
--------------------------------------------------------------------------------
 1 | .main-header {
 2 |     color: var(--colorHeadline);
 3 |     background-color: var(--colorBackground);
 4 | 
 5 |     display: flex;
 6 |     flex-direction: row-reverse;
 7 |     align-items: center;
 8 |     height: 86px;
 9 |     align-content: center;
10 | }
11 | 
12 | .page-title-image {
13 |     flex: 0 74px;
14 | }
15 | 
16 | .page-title-text {
17 |     flex: 1;
18 | }
19 | 
20 | /*.page-image {*/
21 | /*    height: 64px;*/
22 | /*    width: 64px;*/
23 | /*}*/
24 | 
25 | .page-title {
26 |     font-size: 2.5rem;
27 |     font-weight: 600;
28 | }
29 | 
30 | .page-subtitle {
31 |     font-size: 1.5rem;
32 |     font-weight: 600;
33 | }
34 | 
35 | 
36 | 


--------------------------------------------------------------------------------
/web/frontend/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "htmx",
 3 |   "private": true,
 4 |   "version": "0.0.0",
 5 |   "type": "module",
 6 |   "scripts": {
 7 |     "dev": "vite",
 8 |     "build": "vite build",
 9 |     "preview": "vite preview"
10 |   },
11 |   "devDependencies": {
12 |     "cssnano": "^7.0.7",
13 |     "postcss": "^8.5.6",
14 |     "postcss-import": "^16.1.1",
15 |     "postcss-inherit": "^4.1.0",
16 |     "vite": "^6.3.5"
17 |   },
18 |   "dependencies": {
19 |     "@fontsource/noto-sans": "^5.2.7",
20 |     "@fontsource/noto-sans-mono": "^5.2.7",
21 |     "htmx.org": "^2.0.5",
22 |     "katex": "^0.16.22",
23 |     "marked": "^15.0.12",
24 |     "marked-katex-extension": "^5.1.4"
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/web/templates/chat-response.gohtml:
--------------------------------------------------------------------------------
 1 | {{if eq .New true}}
 2 |   <div hx-swap-oob="beforeend:#main .chat-messages">
 3 |     <div class="chat-message user">
 4 |       <div class="raw">
 5 |         {{.UserMessageContent}}
 6 |       </div>
 7 |       <div class="formatted"></div>
 8 |     </div>
 9 |   </div>
10 |   <div hx-swap-oob="beforeend:#main .chat-messages">
11 |     <div class="chat-message assistant">
12 |       <div class="raw">
13 |         {{.AssistantMessageContent}}
14 |       </div>
15 |       <div class="formatted"></div>
16 |     </div>
17 |   </div>
18 | {{else}}
19 |   <div hx-swap-oob="innerHTML:#main .chat-message.assistant:last-child">
20 |     <div class="raw">
21 |       {{.AssistantMessageContent}}
22 |     </div>
23 |     <div class="formatted"></div>
24 |   </div>
25 | {{end}}


--------------------------------------------------------------------------------
/internal/pkg/staticAssets/handler.go:
--------------------------------------------------------------------------------
 1 | package staticAssets
 2 | 
 3 | import (
 4 | 	"embed"
 5 | 	"io/fs"
 6 | 	"net/http"
 7 | 	"os"
 8 | 	"path"
 9 | )
10 | 
11 | type pseudoFs func(name string) (fs.File, error)
12 | 
13 | func (f pseudoFs) Open(name string) (fs.File, error) {
14 | 	return f(name)
15 | }
16 | 
17 | func Handler(embedFs embed.FS, embedFsRoot string, urlPrefix string, defaultUrl string) http.Handler {
18 | 	handler := pseudoFs(func(name string) (fs.File, error) {
19 | 		assetPath := path.Join(embedFsRoot, name)
20 | 
21 | 		file, err := embedFs.Open(assetPath)
22 | 		if os.IsNotExist(err) {
23 | 			return embedFs.Open(path.Join(embedFsRoot, defaultUrl))
24 | 		}
25 | 
26 | 		return file, err
27 | 	})
28 | 
29 | 	return http.StripPrefix(urlPrefix, http.FileServer(http.FS(handler)))
30 | }
31 | 


--------------------------------------------------------------------------------
/web/frontend/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <link rel="icon" type="image/png" href="/logo-s.png" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 7 |     <title>Ricky</title>
 8 |   </head>
 9 |   <script>
10 |     document.fonts.onloadingdone = () => {
11 |       document.body.style.visibility = 'visible';
12 |     }
13 |   </script>
14 |   <body style="visibility: hidden;">
15 |     <div id="loader" class="htmx-indicator" style="opacity:0;">
16 |       <div class="loader-box">
17 |         <div class="loader-spinner"></div>
18 |       </div>
19 |     </div>
20 |     <div id="main" hx-get="/api/main" hx-swap="innerHTML" hx-trigger="load" hx-indicator="#loader"></div>
21 |     <script type="module" src="./main.js"></script>
22 |   </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/web/frontend/css/footer.css:
--------------------------------------------------------------------------------
 1 | .main-footer {
 2 | }
 3 | 
 4 | .user-input-box {
 5 |     display: flex;
 6 |     flex-direction: row;
 7 |     align-items: center;
 8 | }
 9 | 
10 | .user-input {
11 |     flex: auto;
12 |     resize: none;
13 | 
14 |     color: hsl(13, 29%, 6%);
15 |     background-color: hsl(14, 100%, 91%);
16 | 
17 |     font-size: 1.0rem;
18 | 
19 |     margin-top: 0.5em;
20 |     box-sizing: border-box;
21 |     padding: 5px;
22 |     border: none;
23 |     box-shadow: none;
24 |     outline: 0.1rem solid var(--colorButtonText);
25 |     border-radius: 0.5rem;
26 | }
27 | 
28 | .submit-button-box {
29 |     flex: none;
30 |     padding-left: 1rem;
31 | }
32 | 
33 | .disclaimer-box {
34 |     display: flex;
35 |     align-items: center;
36 |     justify-content: center;
37 |     margin: 0.5rem 0;
38 | }
39 | 
40 | .disclaimer {
41 |     font-size: 0.8rem;
42 |     font-weight: 300;
43 | }
44 | 


--------------------------------------------------------------------------------
/internal/pkg/web/response.go:
--------------------------------------------------------------------------------
 1 | package web
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type Response struct {
 8 | 	Status      int
 9 | 	ContentType string
10 | 	Content     []byte
11 | 	Headers     Headers
12 | 	Cookie      *http.Cookie
13 | }
14 | 
15 | func (response *Response) Write(responseWriter http.ResponseWriter) {
16 | 	if response != nil {
17 | 		if response.Cookie != nil {
18 | 			http.SetCookie(responseWriter, response.Cookie)
19 | 		}
20 | 		if response.ContentType != "" {
21 | 			responseWriter.Header().Set("Content-Type", response.ContentType)
22 | 		}
23 | 		for k, v := range response.Headers {
24 | 			responseWriter.Header().Set(k, v)
25 | 		}
26 | 		responseWriter.WriteHeader(response.Status)
27 | 		_, err := responseWriter.Write(response.Content)
28 | 
29 | 		if err != nil {
30 | 			responseWriter.WriteHeader(http.StatusInternalServerError)
31 | 		}
32 | 	} else {
33 | 		responseWriter.WriteHeader(http.StatusOK)
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/cmd/ricky-bot/applicationConfig.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | type applicationConfig struct {
 4 | 	Host           string `config_default:"localhost" config_description:"Server host interface"`
 5 | 	Port           int    `config_default:"8080" config_description:"Server port"`
 6 | 	SimulatedDelay int    `config_default:"0" config_description:"Simulated delay for HTMX interactions in milliseconds"`
 7 | 	McpConfigFile  string `config_default:"./configs/mcp.config.json" config_description:"Path to MCP configuration file"`
 8 | 	ModelName      string `config_default:"ollama:qwen3:8b" config_description:"Model to use for chat"`
 9 | 	SystemPrompt   string `config_default:"You are a helpful AI assistant." config_description:"System prompt for the model"`
10 | 	MaxSteps       int    `config_default:"20" config_description:"Maximum number of steps for the agent"`
11 | 	MessageWindow  int    `config_default:"10" config_description:"Maximum number of messages to keep in history"`
12 | }
13 | 


--------------------------------------------------------------------------------
/web/frontend/css/body.css:
--------------------------------------------------------------------------------
 1 | :root {
 2 |     --colorBackground: hsl(13, 16%, 29%);
 3 |     --colorHeadline: hsl(60, 100%, 100%);
 4 |     --colorParagraph: hsl(22, 100%, 96%);
 5 |     --colorButton: hsl(14, 100%, 84%);
 6 |     --colorButtonText: hsl(13, 22%, 13%);
 7 | 
 8 |     --colorIllustrationStroke: hsl(13, 29%, 6%);
 9 |     --colorIllustrationMain: hsl(22, 100%, 96%);
10 | 
11 |     font-family: 'Noto Sans', sans-serif;
12 |     line-height: 1.5;
13 |     font-weight: 400;
14 | 
15 |     color: var(--colorParagraph);
16 |     background-color: var(--colorBackground);
17 | 
18 |     text-rendering: optimizeLegibility;
19 | }
20 | 
21 | html, body {
22 |     height: 100%;
23 |     margin: 0;
24 |     font-size: 16px;
25 | }
26 | 
27 | #main {
28 |     height: 100%;
29 |     display: flex;
30 |     flex-direction: column;
31 | }
32 | 
33 | .width-values {
34 |     /*max-width: 1280px;*/
35 |     min-width: 800px;
36 |     margin: 0 0;
37 |     padding: 0 2rem;
38 | }
39 | 
40 | .katex {
41 |     font-size: 1.6em;
42 | }


--------------------------------------------------------------------------------
/internal/pkg/web/templates.go:
--------------------------------------------------------------------------------
 1 | package web
 2 | 
 3 | import (
 4 | 	"html/template"
 5 | 	"io/fs"
 6 | 	"strings"
 7 | )
 8 | 
 9 | func TemplateParseFSRecursive(
10 | 	templates fs.FS,
11 | 	templatesDir string,
12 | 	ext string,
13 | 	funcMap template.FuncMap) (*template.Template, error) {
14 | 
15 | 	pathSeparator := "/"
16 | 	templatesDirParts := strings.Split(templatesDir, pathSeparator)
17 | 	templatesDirPartsNum := len(templatesDirParts)
18 | 
19 | 	root := template.New("")
20 | 	err := fs.WalkDir(templates, templatesDir, func(path string, d fs.DirEntry, err error) error {
21 | 		if !d.IsDir() && strings.HasSuffix(path, ext) {
22 | 			if err != nil {
23 | 				return err
24 | 			}
25 | 			b, err := fs.ReadFile(templates, path)
26 | 			if err != nil {
27 | 				return err
28 | 			}
29 | 			parts := strings.Split(path, pathSeparator)
30 | 			name := strings.Join(parts[templatesDirPartsNum:], pathSeparator)
31 | 			t := root.New(name).Funcs(funcMap)
32 | 			_, err = t.Parse(string(b))
33 | 			if err != nil {
34 | 				return err
35 | 			}
36 | 		}
37 | 		return nil
38 | 	})
39 | 	return root, err
40 | }
41 | 


--------------------------------------------------------------------------------
/internal/pkg/web/web.go:
--------------------------------------------------------------------------------
 1 | package web
 2 | 
 3 | import (
 4 | 	"github.com/rs/zerolog/log"
 5 | 
 6 | 	"bytes"
 7 | 	"html/template"
 8 | 	"net/http"
 9 | )
10 | 
11 | func RenderResponse(status int, templates *template.Template, templateName string, data any, headers Headers, cookie *http.Cookie) *Response {
12 | 	var buffer bytes.Buffer
13 | 	if err := templates.ExecuteTemplate(&buffer, templateName, data); err != nil {
14 | 		log.Error().Err(err).Str("template_name", templateName).Msg("templates.ExecuteTemplate() failed")
15 | 		return GetEmptyResponse(http.StatusInternalServerError, nil, nil)
16 | 	}
17 | 
18 | 	return &Response{
19 | 		Status:      status,
20 | 		ContentType: "text/html",
21 | 		Content:     buffer.Bytes(),
22 | 		Headers:     headers,
23 | 		Cookie:      cookie,
24 | 	}
25 | }
26 | 
27 | func GetEmptyResponse(status int, headers Headers, cookie *http.Cookie) *Response {
28 | 	return GetResponse(status, []byte(""), headers, cookie)
29 | }
30 | 
31 | func GetResponse(status int, content []byte, headers Headers, cookie *http.Cookie) *Response {
32 | 	return &Response{
33 | 		Status:  status,
34 | 		Content: content,
35 | 		Headers: headers,
36 | 		Cookie:  cookie,
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/web/frontend/css/button.css:
--------------------------------------------------------------------------------
 1 | .button {
 2 |     background: hsl(14, 100%, 70%);
 3 |     border-radius: .5rem;
 4 |     border: 0.1rem solid var(--colorButtonText);
 5 |     box-sizing: border-box;
 6 |     color: var(--colorButtonText);
 7 |     display: flex;
 8 |     font-family: 'Noto Sans', sans-serif;
 9 |     font-size: 1rem;
10 |     font-weight: 400;
11 |     justify-content: center;
12 |     padding: 0.5rem 1.75rem;
13 |     text-decoration: none;
14 |     width: 100%;
15 |     cursor: pointer;
16 |     user-select: none;
17 |     -webkit-user-select: none;
18 |     touch-action: manipulation;
19 | }
20 | 
21 | .button:hover,
22 | .button-small:hover {
23 |     /*background-image: linear-gradient(-180deg, #1D95C9 0%, #17759C 100%);*/
24 |     background: hsl(14, 100%, 65%);
25 | }
26 | 
27 | .button-small {
28 |     @inherit: .button;
29 | 
30 |     font-size: 0.8rem;
31 |     padding: 0.3rem 1rem;
32 | }
33 | 
34 | .button-small-light {
35 |     @inherit: .button-small;
36 | 
37 |     background-image: linear-gradient(-180deg, #989898 0%, #494949 100%);
38 |     color: #dcdcdc;
39 | }
40 | 
41 | .button-small-light:hover {
42 |     background-image: linear-gradient(-180deg, #787878 0%, #3c3c3c 100%);
43 | }


--------------------------------------------------------------------------------
/internal/pkg/cookies/helpers.go:
--------------------------------------------------------------------------------
 1 | package cookies
 2 | 
 3 | import (
 4 | 	"github.com/google/uuid"
 5 | 	"github.com/rs/zerolog/log"
 6 | 	"net/http"
 7 | )
 8 | 
 9 | const CookieName = "chat-session-id"
10 | 
11 | var SecretKey = []byte(`2pC5z.3;Kk3wsr20,Ool{h;C%:Gq4eN=q\6F"Dfa£GMB[.j0`)
12 | 
13 | func GetIdFromCookie(request *http.Request) uuid.UUID {
14 | 	cookie, err := request.Cookie(CookieName)
15 | 	if err != nil {
16 | 		log.Error().Err(err).Msg("session id cookie can't be retrieved")
17 | 		return uuid.Nil
18 | 	}
19 | 
20 | 	sessionId, err := VerifySignedKeyValue(cookie.Name, cookie.Value, SecretKey)
21 | 	if err != nil {
22 | 		log.Error().Err(err).Msg("session id cookie value can't be verified")
23 | 		return uuid.Nil
24 | 	}
25 | 
26 | 	id, err := uuid.Parse(sessionId)
27 | 	if err != nil {
28 | 		log.Error().Err(err).Msg("session id cookie contains invalid id")
29 | 		return uuid.Nil
30 | 	}
31 | 	return id
32 | }
33 | 
34 | func SetIdToCookie(id uuid.UUID) *http.Cookie {
35 | 	value, err := SignKeyValue(CookieName, id.String(), SecretKey)
36 | 	if err != nil {
37 | 		log.Error().Err(err).Msg("cookies.SignKeyValue() failed")
38 | 		return nil
39 | 	}
40 | 
41 | 	cookie := http.Cookie{
42 | 		Name:     CookieName,
43 | 		Value:    value,
44 | 		Path:     "/",
45 | 		MaxAge:   3600,
46 | 		HttpOnly: true,
47 | 		Secure:   true,
48 | 		SameSite: http.SameSiteLaxMode,
49 | 	}
50 | 
51 | 	return &cookie
52 | }
53 | 


--------------------------------------------------------------------------------
/web/templates/main.gohtml:
--------------------------------------------------------------------------------
 1 | <div hx-ext="ws" ws-connect="/api/notifications">
 2 | </div>
 3 | <div class="main-header width-values">
 4 |     <div class="page-title-text">
 5 |         <span class="page-title">Ricky</span>
 6 |         <span class="page-subtitle"><sup>[ chatty assistant ]</sup></span>
 7 |     </div>
 8 |     <div class="page-title-image">
 9 |         <img class="page-image" src="/chat/logo-s.png" alt="Logo"/>
10 |     </div>
11 | </div>
12 | <div class="main-content width-values">
13 |     <div class="chat-messages">
14 |         {{template "chat-messages.gohtml" .}}
15 |     </div>
16 | </div>
17 | <div class="main-footer width-values">
18 |     <div class="user-input-box">
19 |         <textarea class="user-input" name="user-input" rows="3"  placeholder="Ask Ricky"></textarea>
20 |         <div class="submit-button-box">
21 |             <button class="button"
22 |                     role="button"
23 |                     hx-post="/api/ask"
24 |                     hx-include="[name='user-input']"
25 |                     hx-target=".main-content"
26 |                     hx-swap="none scroll:bottom"
27 |                     hx-indicator="#loader">
28 |                 Send
29 |             </button>
30 |         </div>
31 |     </div>
32 |     <div class="disclaimer-box">
33 |         <div class="disclaimer">
34 |             Ricky is experimental bot UI and AI, so don't expect much at this point
35 |         </div>
36 |     </div>
37 | </div>


--------------------------------------------------------------------------------
/justfile:
--------------------------------------------------------------------------------
 1 | set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 2 | 
 3 | npm-version := `npm -v`
 4 | go-version := `go version`
 5 | set-echo-color := BOLD + "\\e[93m"
 6 | unset-echo-color := NORMAL
 7 | 
 8 | alias a := all
 9 | alias b := build
10 | 
11 | # full application build including dependencies
12 | all: _npm-version _go-version web-full app
13 | 
14 | # build web assets and go binaries
15 | build: web app
16 | 
17 | # build go binaries
18 | app:
19 |   @echo "{{set-echo-color}}*** building go binaries ***{{unset-echo-color}}"
20 |   go fmt ./...
21 |   go mod tidy
22 |   go build -v ./cmd/ricky-bot
23 |   go build -v ./cmd/calculator
24 |   go build -v ./cmd/calculator-mcp
25 | 
26 | # just install web dependencies
27 | [working-directory: "web/frontend"]
28 | web-deps:
29 |   @echo "{{set-echo-color}}*** installing npm libraries ***{{unset-echo-color}}"
30 |   npm install
31 | 
32 | # web assets build
33 | [working-directory: "web/frontend"]
34 | web:
35 |   @echo "{{set-echo-color}}*** running npm build ***{{unset-echo-color}}"
36 |   npm run build
37 | 
38 | # full web assets build including dependencies
39 | [working-directory: "web/frontend"]
40 | web-full: web-deps web
41 | 
42 | _npm-version:
43 |   @echo "{{set-echo-color}}*** npm version {{npm-version}} ***{{unset-echo-color}}"
44 | 
45 | _go-version:
46 |   @echo "{{set-echo-color}}*** {{go-version}} ***{{unset-echo-color}}"
47 | 
48 | run:
49 |     @echo "{{set-echo-color}}*** running application ***{{unset-echo-color}}"
50 |     ./ricky-bot
51 | 


--------------------------------------------------------------------------------
/web/frontend/css/content.css:
--------------------------------------------------------------------------------
 1 | .main-content {
 2 |     flex: 1;
 3 |     overflow: auto;
 4 |     font-size: 1.0rem;
 5 |     line-height: 1.5rem;
 6 | }
 7 | 
 8 | .chat-messages {
 9 |     display: flex;
10 |     flex-direction: column;
11 | }
12 | 
13 | .chat-message .raw{
14 |     display: none;
15 | }
16 | 
17 | .chat-message.user {
18 |     margin-left: 20rem;
19 |     margin-top: 0.5rem;
20 |     margin-bottom: 0.5rem;
21 |     border: 0.1rem solid var(--colorButtonText);
22 |     border-radius: 0.75rem 0.0rem 0.75rem 0.75rem;
23 |     padding: 1rem;
24 | 
25 |     color: var(--colorButtonText);
26 |     background-color: var(--colorButton);
27 | }
28 | 
29 | .chat-message.user .formatted{
30 |     white-space: pre-wrap;
31 | }
32 | 
33 | .chat-message.assistant {
34 |     margin-top: 0.5rem;
35 |     margin-bottom: 0.5rem;
36 |     padding: 1rem;
37 | }
38 | 
39 | .chat-message.assistant .formatted code {
40 |     font-family: "Noto Sans Mono", monospace;
41 |     font-weight: 300;
42 |     font-size: 0.8rem;
43 |     line-height: 1rem;
44 |     padding: 0.25rem 0.25rem;
45 |     border-radius: 0.5rem;
46 |     background-color: hsl(13, 16%, 34%);
47 | }
48 | 
49 | .chat-message.assistant .formatted pre > code {
50 |     padding: 0;
51 |     border-radius: 0;
52 | }
53 | 
54 | .chat-message.assistant .formatted pre  {
55 |     padding: 0.75rem 0.75rem;
56 |     border-radius: 0.5rem;
57 |     background-color: hsl(13, 16%, 34%);
58 |     line-height: 0.9rem;
59 | }
60 | 
61 | /* Styling for think content */
62 | .chat-message.assistant .formatted .think-content {
63 |     background-color: hsl(13, 16%, 54%);
64 |     border-radius: 0.75rem;
65 |     padding: 0.5rem;
66 |     margin: 0.5rem 0;
67 |     color: white;
68 | }
69 | 


--------------------------------------------------------------------------------
/internal/pkg/sessions/sessions.go:
--------------------------------------------------------------------------------
 1 | package sessions
 2 | 
 3 | import (
 4 | 	"ai-chat/internal/pkg/agent"
 5 | 	"ai-chat/internal/pkg/chatSession"
 6 | 	"errors"
 7 | 	"fmt"
 8 | 	"github.com/google/uuid"
 9 | )
10 | 
11 | type SessionManager struct {
12 | 	chatSessions map[uuid.UUID]chatSession.ChatSession
13 | }
14 | 
15 | func New() *SessionManager {
16 | 	sessionManager := &SessionManager{
17 | 		chatSessions: make(map[uuid.UUID]chatSession.ChatSession),
18 | 	}
19 | 	return sessionManager
20 | }
21 | 
22 | func (instance *SessionManager) AddSession(id uuid.UUID, responseFunc chatSession.ChatBlockResponseFunc) error {
23 | 	_, ok := instance.chatSessions[id]
24 | 	if ok {
25 | 		return errors.New("session with such id already exists")
26 | 	}
27 | 
28 | 	chat, err := chatSession.New(responseFunc, "")
29 | 	if err != nil {
30 | 		return fmt.Errorf("chatSession.New() failed: %w", err)
31 | 	}
32 | 
33 | 	instance.chatSessions[id] = chat
34 | 
35 | 	return nil
36 | }
37 | 
38 | func (instance *SessionManager) AddAgentSession(id uuid.UUID, agent *agent.Agent, responseFunc chatSession.ChatBlockResponseFunc) error {
39 | 	_, ok := instance.chatSessions[id]
40 | 	if ok {
41 | 		return errors.New("session with such id already exists")
42 | 	}
43 | 
44 | 	chat, err := chatSession.NewAgentChatSession(agent, responseFunc)
45 | 	if err != nil {
46 | 		return fmt.Errorf("chatSession.NewAgentChatSession() failed: %w", err)
47 | 	}
48 | 
49 | 	instance.chatSessions[id] = chat
50 | 
51 | 	return nil
52 | }
53 | 
54 | func (instance *SessionManager) GetSession(id uuid.UUID) chatSession.ChatSession {
55 | 
56 | 	return instance.chatSessions[id]
57 | }
58 | 
59 | func (instance *SessionManager) Shutdown() {
60 | 	for _, session := range instance.chatSessions {
61 | 		session.Shutdown()
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/cmd/calculator-mcp/README.md:
--------------------------------------------------------------------------------
 1 | # Calculator MCP Server
 2 | 
 3 | This is an implementation of a Model Context Protocol (MCP) server for calculator operations. It provides a set of tools for performing basic arithmetic operations.
 4 | 
 5 | ## Overview
 6 | 
 7 | The Calculator MCP Server is built using the `github.com/mark3labs/mcp-go` library. It implements a stdio server that reads from stdin and writes to stdout, making it suitable for integration with LLM-powered applications that support the MCP protocol.
 8 | 
 9 | ## Tools
10 | 
11 | The following tools are available:
12 | 
13 | - `calculator.add(a, b)` - Adds two numbers
14 | - `calculator.subtract(a, b)` - Subtracts b from a
15 | - `calculator.multiply(a, b)` - Multiplies two numbers
16 | - `calculator.divide(a, b)` - Divides a by b (returns error if b is zero)
17 | 
18 | ## Usage
19 | 
20 | ### Building the server
21 | 
22 | ```bash
23 | # Build the server
24 | go build -o calculator-mcp cmd/calculator-mcp/main.go
25 | 
26 | # Run the server
27 | ./calculator-mcp
28 | ```
29 | 
30 | ### Integration
31 | 
32 | This MCP server is designed to be used with LLM-powered applications that support the MCP protocol. The server communicates through stdin and stdout, so it should be launched as a child process by the application.
33 | 
34 | ## Implementation Details
35 | 
36 | The server is implemented using the `github.com/mark3labs/mcp-go` library. It defines four tools for basic arithmetic operations and handles the requests directly within the server.
37 | 
38 | Each tool accepts two numeric parameters (`a` and `b`) and returns the result of the operation as a formatted string. The divide tool includes a check for division by zero and returns an appropriate error message if the divisor is zero.
39 | 
40 | The server uses the `ServeStdio` function from the `github.com/mark3labs/mcp-go/server` package to handle communication through stdin and stdout.
41 | 


--------------------------------------------------------------------------------
/internal/pkg/httpHandlers/uiTypes.go:
--------------------------------------------------------------------------------
 1 | package httpHandlers
 2 | 
 3 | import (
 4 | 	"ai-chat/internal/pkg/chatSession"
 5 | 	"encoding/base64"
 6 | )
 7 | 
 8 | type UiSessionResponse struct {
 9 | 	UiSession
10 | 	New bool
11 | }
12 | 
13 | type UiSession struct {
14 | 	SystemMessageContent    string
15 | 	UserMessageContent      string
16 | 	AssistantMessageContent string
17 | 	Completed               bool
18 | 	Failed                  bool
19 | }
20 | 
21 | func toUiSession(session chatSession.ChatBlock) UiSession {
22 | 	uiSession := UiSession{
23 | 		SystemMessageContent:    "",
24 | 		UserMessageContent:      "",
25 | 		AssistantMessageContent: "",
26 | 		Completed:               session.Completed,
27 | 		Failed:                  session.Failed}
28 | 
29 | 	if session.SystemMessage != "" {
30 | 		systemMessageContent := base64.StdEncoding.EncodeToString([]byte(session.SystemMessage))
31 | 		uiSession.SystemMessageContent = systemMessageContent
32 | 	}
33 | 
34 | 	if session.UserMessage != "" {
35 | 		userMessageContent := base64.StdEncoding.EncodeToString([]byte(session.UserMessage))
36 | 		uiSession.UserMessageContent = userMessageContent
37 | 	}
38 | 
39 | 	if session.AssistantMessage != "" {
40 | 		assistantMessageContent := base64.StdEncoding.EncodeToString([]byte(session.AssistantMessage))
41 | 		uiSession.AssistantMessageContent = assistantMessageContent
42 | 	}
43 | 
44 | 	return uiSession
45 | }
46 | 
47 | func ToUiSessionResponse(response chatSession.ChatBlockResponse) UiSessionResponse {
48 | 	uiResponse := UiSessionResponse{
49 | 		UiSession: toUiSession(response.ChatBlock),
50 | 		New:       response.New}
51 | 
52 | 	return uiResponse
53 | }
54 | 
55 | func ToUiSessions(sessions []chatSession.ChatBlock) []UiSession {
56 | 	uiSessions := make([]UiSession, len(sessions))
57 | 	for i, session := range sessions {
58 | 		uiSessions[i] = toUiSession(session)
59 | 	}
60 | 	return uiSessions
61 | }
62 | 


--------------------------------------------------------------------------------
/internal/pkg/cookies/cookies.go:
--------------------------------------------------------------------------------
 1 | package cookies
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"crypto/hmac"
 6 | 	"crypto/sha256"
 7 | 	"encoding/base64"
 8 | 	"errors"
 9 | 	"fmt"
10 | )
11 | 
12 | var signKeyValueError = func(err error) error {
13 | 	return fmt.Errorf("error signing key value: %w", err)
14 | }
15 | 
16 | func SignKeyValue(key string, value string, secretKey []byte) (string, error) {
17 | 	if key == "" {
18 | 		return "", signKeyValueError(errors.New("empty key"))
19 | 	}
20 | 
21 | 	if value == "" {
22 | 		return "", signKeyValueError(errors.New("empty value"))
23 | 	}
24 | 
25 | 	mac := hmac.New(sha256.New, secretKey)
26 | 	mac.Write([]byte(key))
27 | 	mac.Write([]byte(value))
28 | 	signature := mac.Sum(nil)
29 | 
30 | 	var result bytes.Buffer
31 | 	result.Write(signature)
32 | 	result.Write([]byte(value))
33 | 
34 | 	return base64.StdEncoding.EncodeToString(result.Bytes()), nil
35 | }
36 | 
37 | var verifySignedKeyValueError = func(err error) error {
38 | 	return fmt.Errorf("error verifying signed key value: %w", err)
39 | }
40 | 
41 | func VerifySignedKeyValue(key string, signedValue string, secretKey []byte) (string, error) {
42 | 	if key == "" {
43 | 		return "", verifySignedKeyValueError(errors.New("empty key"))
44 | 	}
45 | 
46 | 	if signedValue == "" {
47 | 		return "", verifySignedKeyValueError(errors.New("empty signedValue"))
48 | 	}
49 | 
50 | 	signedValueBytes, err := base64.StdEncoding.DecodeString(signedValue)
51 | 	if err != nil {
52 | 		return "", verifySignedKeyValueError(err)
53 | 	}
54 | 
55 | 	if len(signedValueBytes) < sha256.Size {
56 | 		return "", verifySignedKeyValueError(errors.New("signed value is too short"))
57 | 	}
58 | 
59 | 	signature := signedValueBytes[:sha256.Size]
60 | 	value := signedValueBytes[sha256.Size:]
61 | 
62 | 	mac := hmac.New(sha256.New, secretKey)
63 | 	mac.Write([]byte(key))
64 | 	mac.Write(value)
65 | 	expectedSignature := mac.Sum(nil)
66 | 
67 | 	if !hmac.Equal(signature, expectedSignature) {
68 | 		return "", verifySignedKeyValueError(errors.New("invalid signature"))
69 | 	}
70 | 
71 | 	return string(value), nil
72 | }
73 | 


--------------------------------------------------------------------------------
/web/frontend/css/loader.css:
--------------------------------------------------------------------------------
 1 | .htmx-indicator{
 2 |   opacity:0 !important;
 3 |   transition: opacity 0ms linear !important;
 4 | }
 5 | 
 6 | .htmx-request.htmx-indicator{
 7 |   opacity:1 !important;
 8 |   transition: opacity 250ms linear !important;
 9 |   transition-delay: 250ms !important;
10 | }
11 | 
12 | /*.htmx-request .htmx-indicator{*/
13 | /*  @inherit: .htmx-request.htmx-indicator;*/
14 | /*}*/
15 | 
16 | .loader-box {
17 |   position: absolute;
18 |   left: 50%;
19 |   top: 50%;
20 |   transform: translate(-50%, -50%);
21 | 
22 |   width: 100px;
23 |   height: 100px;
24 |   /*border: 2px dotted rgb(96 139 168);*/
25 |   background: #2e2e2e;
26 |   display: flex;
27 |   align-items: center;
28 |   justify-content: center;
29 | }
30 | 
31 | .loader-spinner {
32 |   width: 40px;
33 |   aspect-ratio: 1;
34 |   --c: linear-gradient(#ffffff 0 0, #ffffff);
35 |   --r1: radial-gradient(farthest-side at bottom, #ffffff 93%, #0000);
36 |   --r2: radial-gradient(farthest-side at top, #ffffff 93%, #0000);
37 |   background:
38 |           var(--c) ,var(--r1),var(--r2),
39 |           var(--c) ,var(--r1),var(--r2),
40 |           var(--c) ,var(--r1),var(--r2);
41 |   background-repeat: no-repeat;
42 |   animation: loader-frames 1s infinite alternate;
43 | }
44 | 
45 | @keyframes loader-frames {
46 |   0%,25% {
47 |     background-size: 8px 0,8px 4px,8px 4px,8px 0,8px 4px,8px 4px,8px 0,8px 4px,8px 4px;
48 |     background-position: 0 50%,0 calc(50% - 2px),0 calc(50% + 2px),50% 50%,50% calc(50% - 2px),50% calc(50% + 2px),100% 50%,100% calc(50% - 2px),100% calc(50% + 2px);
49 |   }
50 |   50% {
51 |     background-size: 8px 100%,8px 4px,8px 4px,8px 0,8px 4px,8px 4px,8px 0,8px 4px,8px 4px;
52 |     background-position: 0 50%,0 calc(0% - 2px),0 calc(100% + 2px),50% 50%,50% calc(50% - 2px),50% calc(50% + 2px),100% 50%,100% calc(50% - 2px),100% calc(50% + 2px);
53 |   }
54 |   75% {
55 |     background-size: 8px 100%,8px 4px,8px 4px,8px 100%,8px 4px,8px 4px,8px 0,8px 4px,8px 4px;
56 |     background-position: 0 50%,0 calc(0% - 2px),0 calc(100% + 2px),50% 50%,50% calc(0% - 2px),50% calc(100% + 2px),100% 50%,100% calc(50% - 2px),100% calc(50% + 2px);
57 |   }
58 |   95%,100% {
59 |     background-size: 8px 100%,8px 4px, 8px 4px,8px 100%,8px 4px,8px 4px,8px 100%,8px 4px,8px 4px;
60 |     background-position: 0 50%,0 calc(0% - 2px),0 calc(100% + 2px),50% 50%,50% calc(0% - 2px),50% calc(100% + 2px),100% 50%,100% calc(0% - 2px),100% calc(100% + 2px);
61 |   }
62 | }


--------------------------------------------------------------------------------
/internal/pkg/config/config.go:
--------------------------------------------------------------------------------
  1 | package config
  2 | 
  3 | import (
  4 | 	"github.com/rs/zerolog/log"
  5 | 	"github.com/spf13/pflag"
  6 | 	"github.com/spf13/viper"
  7 | 	"reflect"
  8 | 	"strconv"
  9 | )
 10 | 
 11 | func parseConfigStruct(config any) {
 12 | 	valueOf := reflect.ValueOf(config).Elem()
 13 | 	structType := valueOf.Type()
 14 | 	//structType := reflect.TypeOf(config)
 15 | 
 16 | 	for i := 0; i < structType.NumField(); i++ {
 17 | 		field := structType.Field(i)
 18 | 
 19 | 		keyValue := field.Name
 20 | 		defaultValue := field.Tag.Get("config_default")
 21 | 
 22 | 		//if defaultValue == "" {
 23 | 		//	log.Panic().Str("config_default", keyValue).Msg("default value is empty")
 24 | 		//}
 25 | 
 26 | 		description := field.Tag.Get("config_description")
 27 | 		if description == "" {
 28 | 			log.Panic().Str("config_description", keyValue).Msg("description value is empty")
 29 | 		}
 30 | 
 31 | 		kind := field.Type.Kind()
 32 | 		switch kind {
 33 | 		case reflect.Int:
 34 | 			setIntItem(keyValue, defaultValue, description)
 35 | 			break
 36 | 		case reflect.String:
 37 | 			setStringItem(keyValue, defaultValue, description)
 38 | 			break
 39 | 		default:
 40 | 			log.Panic().Str("config_item", keyValue).Str("type", kind.String()).Msg("unsupported type")
 41 | 		}
 42 | 	}
 43 | }
 44 | 
 45 | // Parse configuration from command line, environment variables, config file
 46 | // Configuration options order precedence (from highest to lowest):
 47 | // - command line flag
 48 | // - environment variable
 49 | // - config file entry
 50 | // - default value
 51 | func Parse(config any, envPrefix string) {
 52 | 	viper.SetEnvPrefix(envPrefix)
 53 | 	configFileKey := "ConfigFile"
 54 | 	weirdValue := "&^%"
 55 | 	pflag.StringP(configFileKey, "c", weirdValue, "Config file location")
 56 | 	pflag.Lookup(configFileKey).DefValue = ""
 57 | 
 58 | 	parseConfigStruct(config)
 59 | 	parseFlags()
 60 | 
 61 | 	configFile := viper.GetString(configFileKey)
 62 | 	if configFile != weirdValue {
 63 | 		readConfig(configFile)
 64 | 	}
 65 | 
 66 | 	err := viper.Unmarshal(config)
 67 | 	if err != nil {
 68 | 		log.Fatal().Err(err).Msg("viper.Unmarshal() failed")
 69 | 	}
 70 | }
 71 | 
 72 | func parseFlags() {
 73 | 	pflag.Parse()
 74 | 	err := viper.BindPFlags(pflag.CommandLine)
 75 | 	if err != nil {
 76 | 		log.Fatal().Err(err).Msg("viper.BindPFlags() failed")
 77 | 	}
 78 | }
 79 | func readConfig(configFile string) {
 80 | 	viper.SetConfigFile(configFile)
 81 | 	if err := viper.ReadInConfig(); err != nil {
 82 | 		log.Fatal().Err(err).Msg("viper.ReadInConfig() failed")
 83 | 	}
 84 | }
 85 | 
 86 | func setIntItem(keyValue string, defaultValue string, description string) {
 87 | 	intDefaultValue, err := strconv.Atoi(defaultValue)
 88 | 	if err != nil {
 89 | 		log.Panic().Err(err).Str("config_item", keyValue).Msg("strconv.Atoi() failed")
 90 | 	}
 91 | 	viper.SetDefault(keyValue, intDefaultValue)
 92 | 	bindEnv(keyValue)
 93 | 	pflag.Int(keyValue, intDefaultValue, description)
 94 | }
 95 | 
 96 | func setStringItem(keyValue string, defaultValue string, description string) {
 97 | 	viper.SetDefault(keyValue, defaultValue)
 98 | 	bindEnv(keyValue)
 99 | 	pflag.String(keyValue, defaultValue, description)
100 | }
101 | 
102 | func bindEnv(keyValue string) {
103 | 	err := viper.BindEnv(keyValue)
104 | 	if err != nil {
105 | 		log.Panic().Err(err).Str("config_item", keyValue).Msg("viper.BindEnv() failed")
106 | 	}
107 | }
108 | 


--------------------------------------------------------------------------------
/internal/pkg/cookies/cookies_test.go:
--------------------------------------------------------------------------------
  1 | package cookies
  2 | 
  3 | import (
  4 | 	"encoding/base64"
  5 | 	"github.com/stretchr/testify/assert"
  6 | 	"testing"
  7 | )
  8 | 
  9 | func TestSignKeyValuePositive(t *testing.T) {
 10 | 	key := "testKey"
 11 | 	value := "testValue"
 12 | 	secretKey := []byte("testSecretKey")
 13 | 
 14 | 	signedValue, err := SignKeyValue(key, value, secretKey)
 15 | 	assert.NotEmpty(t, signedValue)
 16 | 	assert.NoError(t, err)
 17 | }
 18 | 
 19 | func TestSignKeyValueNegativeEmptyKey(t *testing.T) {
 20 | 	key := ""
 21 | 	value := "testValue"
 22 | 	secretKey := []byte("testSecretKey")
 23 | 
 24 | 	signedValue, err := SignKeyValue(key, value, secretKey)
 25 | 	assert.Empty(t, signedValue)
 26 | 	assert.EqualError(t, err, "error signing key value: empty key")
 27 | }
 28 | 
 29 | func TestSignKeyValueNegativeEmptyValue(t *testing.T) {
 30 | 	key := "testKey"
 31 | 	value := ""
 32 | 	secretKey := []byte("testSecretKey")
 33 | 
 34 | 	signedValue, err := SignKeyValue(key, value, secretKey)
 35 | 	assert.Empty(t, signedValue)
 36 | 	assert.EqualError(t, err, "error signing key value: empty value")
 37 | }
 38 | 
 39 | func TestVerifySignedKeyValuePositive(t *testing.T) {
 40 | 	key := "testKey"
 41 | 	value := "testValue"
 42 | 	secretKey := []byte("testSecretKey")
 43 | 
 44 | 	signedValue, err := SignKeyValue(key, value, secretKey)
 45 | 	assert.NotEmpty(t, signedValue)
 46 | 	assert.NoError(t, err)
 47 | 
 48 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 49 | 	assert.Equal(t, value, verifiedValue)
 50 | 	assert.NoError(t, err)
 51 | }
 52 | 
 53 | func TestVerifySignedKeyValueNegativeEmptyKey(t *testing.T) {
 54 | 	key := ""
 55 | 	signedValue := "testValue"
 56 | 	secretKey := []byte("testSecretKey")
 57 | 
 58 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 59 | 	assert.Empty(t, verifiedValue)
 60 | 	assert.EqualError(t, err, "error verifying signed key value: empty key")
 61 | }
 62 | 
 63 | func TestVerifySignedKeyValueNegativeEmptySignedValue(t *testing.T) {
 64 | 	key := "testKey"
 65 | 	signedValue := ""
 66 | 	secretKey := []byte("testSecretKey")
 67 | 
 68 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 69 | 	assert.Empty(t, verifiedValue)
 70 | 	assert.EqualError(t, err, "error verifying signed key value: empty signedValue")
 71 | }
 72 | 
 73 | func TestVerifySignedKeyValueNegativeSignedValueEncoding(t *testing.T) {
 74 | 	key := "testKey"
 75 | 	signedValue := "It is not BASE64 encoded value"
 76 | 	secretKey := []byte("testSecretKey")
 77 | 
 78 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 79 | 	assert.Empty(t, verifiedValue)
 80 | 	assert.EqualError(t, err, "error verifying signed key value: illegal base64 data at input byte 2")
 81 | }
 82 | 
 83 | func TestVerifySignedKeyValueNegativeSignedValueTooShort(t *testing.T) {
 84 | 	key := "testKey"
 85 | 	signedValue := base64.StdEncoding.EncodeToString([]byte("test"))
 86 | 	secretKey := []byte("testSecretKey")
 87 | 
 88 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 89 | 	assert.Empty(t, verifiedValue)
 90 | 	assert.EqualError(t, err, "error verifying signed key value: signed value is too short")
 91 | }
 92 | 
 93 | func TestVerifySignedKeyValueNegativeInvalidSignature(t *testing.T) {
 94 | 	key := "testKey"
 95 | 	signedValue := base64.StdEncoding.EncodeToString([]byte("test test test test test test test test test test test"))
 96 | 	secretKey := []byte("testSecretKey")
 97 | 
 98 | 	verifiedValue, err := VerifySignedKeyValue(key, signedValue, secretKey)
 99 | 	assert.Empty(t, verifiedValue)
100 | 	assert.EqualError(t, err, "error verifying signed key value: invalid signature")
101 | }
102 | 


--------------------------------------------------------------------------------
/cmd/calculator-mcp/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"fmt"
  6 | 
  7 | 	"github.com/mark3labs/mcp-go/mcp"
  8 | 	"github.com/mark3labs/mcp-go/server"
  9 | )
 10 | 
 11 | func main() {
 12 | 	// Create a new MCP server
 13 | 	s := server.NewMCPServer(
 14 | 		"Calculator 🧮",
 15 | 		"1.0.0",
 16 | 		server.WithToolCapabilities(false),
 17 | 	)
 18 | 
 19 | 	// Add add tool
 20 | 	addTool := mcp.NewTool("calculator.add",
 21 | 		mcp.WithDescription("Add two numbers"),
 22 | 		mcp.WithNumber("a",
 23 | 			mcp.Required(),
 24 | 			mcp.Description("First number"),
 25 | 		),
 26 | 		mcp.WithNumber("b",
 27 | 			mcp.Required(),
 28 | 			mcp.Description("Second number"),
 29 | 		),
 30 | 	)
 31 | 
 32 | 	// Add subtract tool
 33 | 	subtractTool := mcp.NewTool("calculator.subtract",
 34 | 		mcp.WithDescription("Subtract second number from first number"),
 35 | 		mcp.WithNumber("a",
 36 | 			mcp.Required(),
 37 | 			mcp.Description("First number"),
 38 | 		),
 39 | 		mcp.WithNumber("b",
 40 | 			mcp.Required(),
 41 | 			mcp.Description("Second number"),
 42 | 		),
 43 | 	)
 44 | 
 45 | 	// Add multiply tool
 46 | 	multiplyTool := mcp.NewTool("calculator.multiply",
 47 | 		mcp.WithDescription("Multiply two numbers"),
 48 | 		mcp.WithNumber("a",
 49 | 			mcp.Required(),
 50 | 			mcp.Description("First number"),
 51 | 		),
 52 | 		mcp.WithNumber("b",
 53 | 			mcp.Required(),
 54 | 			mcp.Description("Second number"),
 55 | 		),
 56 | 	)
 57 | 
 58 | 	// Add divide tool
 59 | 	divideTool := mcp.NewTool("calculator.divide",
 60 | 		mcp.WithDescription("Divide first number by second number"),
 61 | 		mcp.WithNumber("a",
 62 | 			mcp.Required(),
 63 | 			mcp.Description("First number (dividend)"),
 64 | 		),
 65 | 		mcp.WithNumber("b",
 66 | 			mcp.Required(),
 67 | 			mcp.Description("Second number (divisor)"),
 68 | 		),
 69 | 	)
 70 | 
 71 | 	// Add tool handlers
 72 | 	s.AddTool(addTool, addHandler)
 73 | 	s.AddTool(subtractTool, subtractHandler)
 74 | 	s.AddTool(multiplyTool, multiplyHandler)
 75 | 	s.AddTool(divideTool, divideHandler)
 76 | 
 77 | 	// Start the stdio server
 78 | 	if err := server.ServeStdio(s); err != nil {
 79 | 		fmt.Printf("Server error: %v\n", err)
 80 | 	}
 81 | }
 82 | 
 83 | func addHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 84 | 	a, err := request.RequireFloat("a")
 85 | 	if err != nil {
 86 | 		return mcp.NewToolResultError(err.Error()), nil
 87 | 	}
 88 | 
 89 | 	b, err := request.RequireFloat("b")
 90 | 	if err != nil {
 91 | 		return mcp.NewToolResultError(err.Error()), nil
 92 | 	}
 93 | 
 94 | 	result := a + b
 95 | 	return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
 96 | }
 97 | 
 98 | func subtractHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 99 | 	a, err := request.RequireFloat("a")
100 | 	if err != nil {
101 | 		return mcp.NewToolResultError(err.Error()), nil
102 | 	}
103 | 
104 | 	b, err := request.RequireFloat("b")
105 | 	if err != nil {
106 | 		return mcp.NewToolResultError(err.Error()), nil
107 | 	}
108 | 
109 | 	result := a - b
110 | 	return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
111 | }
112 | 
113 | func multiplyHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
114 | 	a, err := request.RequireFloat("a")
115 | 	if err != nil {
116 | 		return mcp.NewToolResultError(err.Error()), nil
117 | 	}
118 | 
119 | 	b, err := request.RequireFloat("b")
120 | 	if err != nil {
121 | 		return mcp.NewToolResultError(err.Error()), nil
122 | 	}
123 | 
124 | 	result := a * b
125 | 	return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
126 | }
127 | 
128 | func divideHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
129 | 	a, err := request.RequireFloat("a")
130 | 	if err != nil {
131 | 		return mcp.NewToolResultError(err.Error()), nil
132 | 	}
133 | 
134 | 	b, err := request.RequireFloat("b")
135 | 	if err != nil {
136 | 		return mcp.NewToolResultError(err.Error()), nil
137 | 	}
138 | 
139 | 	if b == 0 {
140 | 		return mcp.NewToolResultError("Division by zero is not allowed"), nil
141 | 	}
142 | 
143 | 	result := a / b
144 | 	return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
145 | }
146 | 


--------------------------------------------------------------------------------
/internal/pkg/websocketServer/websocketServerImpl.go:
--------------------------------------------------------------------------------
  1 | package websocketServer
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/cookies"
  5 | 	"context"
  6 | 	"errors"
  7 | 	"github.com/coder/websocket"
  8 | 	"github.com/google/uuid"
  9 | 	"github.com/rs/zerolog/log"
 10 | 	"net/http"
 11 | 	"sync"
 12 | 	"time"
 13 | )
 14 | 
 15 | type messagePacket struct {
 16 | 	Id      uuid.UUID
 17 | 	Message []byte
 18 | }
 19 | 
 20 | const subscriberMessageBufferSize = 16
 21 | 
 22 | type websocketServerImpl struct {
 23 | 	mutex       sync.Mutex
 24 | 	subscribers map[*serverSubscriber]any
 25 | }
 26 | 
 27 | func New() WebsocketServer {
 28 | 	wsNotificationServer := &websocketServerImpl{
 29 | 		subscribers: make(map[*serverSubscriber]any),
 30 | 	}
 31 | 	return wsNotificationServer
 32 | }
 33 | 
 34 | type serverSubscriber struct {
 35 | 	messageChannel chan messagePacket
 36 | 	closeSlow      func()
 37 | }
 38 | 
 39 | func (instance *websocketServerImpl) Handler(responseWriter http.ResponseWriter, request *http.Request) {
 40 | 	id := cookies.GetIdFromCookie(request)
 41 | 	if id == uuid.Nil {
 42 | 		http.Error(responseWriter, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 43 | 		return
 44 | 	}
 45 | 
 46 | 	err := instance.subscribe(responseWriter, request, id)
 47 | 	if errors.Is(err, context.Canceled) {
 48 | 		return
 49 | 	}
 50 | 
 51 | 	if websocket.CloseStatus(err) == websocket.StatusNormalClosure ||
 52 | 		websocket.CloseStatus(err) == websocket.StatusGoingAway {
 53 | 		return
 54 | 	}
 55 | 
 56 | 	if err != nil {
 57 | 		log.Error().Err(err).Msg("subscribe() failed")
 58 | 		return
 59 | 	}
 60 | }
 61 | 
 62 | func (instance *websocketServerImpl) subscribe(responseWriter http.ResponseWriter, request *http.Request, id uuid.UUID) error {
 63 | 	websocketConnection, err := websocket.Accept(responseWriter, request, nil)
 64 | 	if err != nil {
 65 | 		// Accept will write a response to responseWriter on all errors
 66 | 		log.Error().Err(err).Msg("websocket.Accept() failed")
 67 | 		return err
 68 | 	}
 69 | 
 70 | 	defer func() {
 71 | 		err := websocketConnection.CloseNow()
 72 | 		if err != nil {
 73 | 			log.Error().Err(err).Msg("websocket.Conn.CloseNow() failed")
 74 | 		}
 75 | 	}()
 76 | 
 77 | 	subscriber := &serverSubscriber{
 78 | 		messageChannel: make(chan messagePacket, subscriberMessageBufferSize),
 79 | 		closeSlow: func() {
 80 | 			if websocketConnection != nil {
 81 | 				err := websocketConnection.Close(websocket.StatusPolicyViolation, "connection too slow to keep up with messages")
 82 | 				if err != nil {
 83 | 					log.Error().Err(err).Msg("websocket.Conn.Close() failed")
 84 | 				}
 85 | 			}
 86 | 		},
 87 | 	}
 88 | 
 89 | 	instance.addSubscriber(subscriber)
 90 | 	defer instance.deleteSubscriber(subscriber)
 91 | 
 92 | 	ctx := websocketConnection.CloseRead(context.Background())
 93 | 
 94 | 	for {
 95 | 		select {
 96 | 		case packet := <-subscriber.messageChannel:
 97 | 			if packet.Id == id {
 98 | 				err := writeTimeout(ctx, time.Second*5, websocketConnection, packet.Message)
 99 | 				if err != nil {
100 | 					return err
101 | 				}
102 | 			}
103 | 		case <-ctx.Done():
104 | 			return ctx.Err()
105 | 		}
106 | 	}
107 | }
108 | 
109 | func (instance *websocketServerImpl) Publish(id uuid.UUID, message []byte) {
110 | 	instance.mutex.Lock()
111 | 	defer instance.mutex.Unlock()
112 | 
113 | 	for subscriber := range instance.subscribers {
114 | 		select {
115 | 		case subscriber.messageChannel <- messagePacket{Id: id, Message: message}:
116 | 		default:
117 | 			go subscriber.closeSlow()
118 | 		}
119 | 	}
120 | }
121 | 
122 | func (instance *websocketServerImpl) addSubscriber(subscriber *serverSubscriber) {
123 | 	instance.mutex.Lock()
124 | 	instance.subscribers[subscriber] = struct{}{}
125 | 	instance.mutex.Unlock()
126 | }
127 | 
128 | func (instance *websocketServerImpl) deleteSubscriber(subscriber *serverSubscriber) {
129 | 	instance.mutex.Lock()
130 | 	delete(instance.subscribers, subscriber)
131 | 	instance.mutex.Unlock()
132 | }
133 | 
134 | func writeTimeout(ctx context.Context, timeout time.Duration, websocketConnection *websocket.Conn, msg []byte) error {
135 | 	writeCtx, cancel := context.WithTimeout(ctx, timeout)
136 | 	defer cancel()
137 | 
138 | 	err := websocketConnection.Write(writeCtx, websocket.MessageText, msg)
139 | 	if err != nil {
140 | 		log.Error().Err(err).Msg("websocket.Conn.Write() failed")
141 | 		return err
142 | 	}
143 | 
144 | 	return nil
145 | }
146 | 


--------------------------------------------------------------------------------
/internal/pkg/models/providers.go:
--------------------------------------------------------------------------------
  1 | package models
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/models/gemini"
  5 | 	"context"
  6 | 	"fmt"
  7 | 	"github.com/cloudwego/eino-ext/components/model/claude"
  8 | 	"github.com/cloudwego/eino-ext/components/model/ollama"
  9 | 	"github.com/cloudwego/eino-ext/components/model/openai"
 10 | 	"github.com/cloudwego/eino/components/model"
 11 | 	"google.golang.org/genai"
 12 | 	"os"
 13 | 	"strings"
 14 | )
 15 | 
 16 | // ProviderConfig holds configuration for creating LLM providers
 17 | type ProviderConfig struct {
 18 | 	ModelString      string
 19 | 	SystemPrompt     string
 20 | 	AnthropicAPIKey  string
 21 | 	AnthropicBaseURL string
 22 | 	OpenAIAPIKey     string
 23 | 	OpenAIBaseURL    string
 24 | 	GoogleAPIKey     string
 25 | }
 26 | 
 27 | // CreateProvider creates an eino ToolCallingChatModel based on the provider configuration
 28 | func CreateProvider(ctx context.Context, config *ProviderConfig) (model.ToolCallingChatModel, error) {
 29 | 	parts := strings.SplitN(config.ModelString, ":", 2)
 30 | 	if len(parts) < 2 {
 31 | 		return nil, fmt.Errorf("invalid model format. Expected provider:model, got %s", config.ModelString)
 32 | 	}
 33 | 
 34 | 	provider := parts[0]
 35 | 	modelName := parts[1]
 36 | 
 37 | 	switch provider {
 38 | 	case "anthropic":
 39 | 		return createAnthropicProvider(ctx, config, modelName)
 40 | 	case "openai":
 41 | 		return createOpenAIProvider(ctx, config, modelName)
 42 | 	case "google":
 43 | 		return createGoogleProvider(ctx, config, modelName)
 44 | 	case "ollama":
 45 | 		return createOllamaProvider(ctx, config, modelName)
 46 | 	default:
 47 | 		return nil, fmt.Errorf("unsupported provider: %s", provider)
 48 | 	}
 49 | }
 50 | 
 51 | func createAnthropicProvider(ctx context.Context, config *ProviderConfig, modelName string) (model.ToolCallingChatModel, error) {
 52 | 	apiKey := config.AnthropicAPIKey
 53 | 	if apiKey == "" {
 54 | 		apiKey = os.Getenv("ANTHROPIC_API_KEY")
 55 | 	}
 56 | 	if apiKey == "" {
 57 | 		return nil, fmt.Errorf("Anthropic API key not provided. Use --anthropic-api-key flag or ANTHROPIC_API_KEY environment variable")
 58 | 	}
 59 | 
 60 | 	claudeConfig := &claude.Config{
 61 | 		APIKey:    apiKey,
 62 | 		Model:     modelName,
 63 | 		MaxTokens: 4096,
 64 | 	}
 65 | 
 66 | 	if config.AnthropicBaseURL != "" {
 67 | 		claudeConfig.BaseURL = &config.AnthropicBaseURL
 68 | 	}
 69 | 
 70 | 	return claude.NewChatModel(ctx, claudeConfig)
 71 | }
 72 | 
 73 | func createOpenAIProvider(ctx context.Context, config *ProviderConfig, modelName string) (model.ToolCallingChatModel, error) {
 74 | 	apiKey := config.OpenAIAPIKey
 75 | 	if apiKey == "" {
 76 | 		apiKey = os.Getenv("OPENAI_API_KEY")
 77 | 	}
 78 | 	if apiKey == "" {
 79 | 		return nil, fmt.Errorf("OpenAI API key not provided. Use --openai-api-key flag or OPENAI_API_KEY environment variable")
 80 | 	}
 81 | 
 82 | 	openaiConfig := &openai.ChatModelConfig{
 83 | 		APIKey: apiKey,
 84 | 		Model:  modelName,
 85 | 	}
 86 | 
 87 | 	if config.OpenAIBaseURL != "" {
 88 | 		openaiConfig.BaseURL = config.OpenAIBaseURL
 89 | 	}
 90 | 
 91 | 	return openai.NewChatModel(ctx, openaiConfig)
 92 | }
 93 | 
 94 | func createGoogleProvider(ctx context.Context, config *ProviderConfig, modelName string) (model.ToolCallingChatModel, error) {
 95 | 	apiKey := config.GoogleAPIKey
 96 | 	if apiKey == "" {
 97 | 		apiKey = os.Getenv("GOOGLE_API_KEY")
 98 | 	}
 99 | 	if apiKey == "" {
100 | 		apiKey = os.Getenv("GEMINI_API_KEY")
101 | 	}
102 | 	if apiKey == "" {
103 | 		return nil, fmt.Errorf("Google API key not provided. Use --google-api-key flag or GOOGLE_API_KEY/GEMINI_API_KEY environment variable")
104 | 	}
105 | 
106 | 	client, err := genai.NewClient(ctx, &genai.ClientConfig{
107 | 		APIKey:  apiKey,
108 | 		Backend: genai.BackendGeminiAPI,
109 | 	})
110 | 	if err != nil {
111 | 		return nil, fmt.Errorf("failed to create Google client: %v", err)
112 | 	}
113 | 
114 | 	geminiConfig := &gemini.Config{
115 | 		Client: client,
116 | 		Model:  modelName,
117 | 	}
118 | 
119 | 	return gemini.NewChatModel(ctx, geminiConfig)
120 | }
121 | 
122 | func createOllamaProvider(ctx context.Context, config *ProviderConfig, modelName string) (model.ToolCallingChatModel, error) {
123 | 	ollamaConfig := &ollama.ChatModelConfig{
124 | 		BaseURL: "http://localhost:11434", // Default Ollama URL
125 | 		Model:   modelName,
126 | 	}
127 | 
128 | 	// Check for custom Ollama host
129 | 	if host := os.Getenv("OLLAMA_HOST"); host != "" {
130 | 		ollamaConfig.BaseURL = host
131 | 	}
132 | 
133 | 	return ollama.NewChatModel(ctx, ollamaConfig)
134 | }
135 | 


--------------------------------------------------------------------------------
/internal/pkg/httpHandlers/chatHandlers.go:
--------------------------------------------------------------------------------
  1 | package httpHandlers
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/agent"
  5 | 	"ai-chat/internal/pkg/chatSession"
  6 | 	"ai-chat/internal/pkg/cookies"
  7 | 	"ai-chat/internal/pkg/sessions"
  8 | 	"ai-chat/internal/pkg/web"
  9 | 	"ai-chat/internal/pkg/websocketServer"
 10 | 	"bytes"
 11 | 	"github.com/cloudwego/eino/schema"
 12 | 	"github.com/google/uuid"
 13 | 	"github.com/rs/zerolog/log"
 14 | 	"html/template"
 15 | 	"net/http"
 16 | 	"sync"
 17 | 	"time"
 18 | )
 19 | 
 20 | type ChatHandlers struct {
 21 | 	templates          *template.Template
 22 | 	notificationServer websocketServer.WebsocketServer
 23 | 	sessionManager     *sessions.SessionManager
 24 | 	mcpAgent           *agent.Agent
 25 | 	sessionMessages    map[uuid.UUID][]*schema.Message
 26 | 	sessionMutex       sync.RWMutex
 27 | }
 28 | 
 29 | func New(templates *template.Template, sessionManager *sessions.SessionManager,
 30 | 	notificationServer websocketServer.WebsocketServer, mcpAgent *agent.Agent) *ChatHandlers {
 31 | 	return &ChatHandlers{
 32 | 		templates:          templates,
 33 | 		sessionManager:     sessionManager,
 34 | 		notificationServer: notificationServer,
 35 | 		mcpAgent:           mcpAgent,
 36 | 		sessionMessages:    make(map[uuid.UUID][]*schema.Message),
 37 | 		sessionMutex:       sync.RWMutex{},
 38 | 	}
 39 | }
 40 | 
 41 | func (instance *ChatHandlers) Main(request *http.Request, simulatedDelay int) *web.Response {
 42 | 	time.Sleep(time.Duration(simulatedDelay) * time.Millisecond)
 43 | 
 44 | 	var cookie *http.Cookie
 45 | 	var id uuid.UUID
 46 | 	id = cookies.GetIdFromCookie(request)
 47 | 	if id == uuid.Nil || instance.sessionManager.GetSession(id) == nil {
 48 | 		var err error
 49 | 		id, err = uuid.NewUUID()
 50 | 		if err != nil {
 51 | 			return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
 52 | 		}
 53 | 
 54 | 		cookie = cookies.SetIdToCookie(id)
 55 | 		if cookie == nil {
 56 | 			return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
 57 | 		}
 58 | 
 59 | 		err = instance.sessionManager.AddAgentSession(id, instance.mcpAgent, instance.chatBlockResponseHandler(id))
 60 | 		if err != nil {
 61 | 			log.Error().Err(err).Msg("sessionManager.AddAgentSession() failed")
 62 | 			return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
 63 | 		}
 64 | 	}
 65 | 
 66 | 	session := instance.sessionManager.GetSession(id)
 67 | 	if session == nil {
 68 | 		log.Error().Msg("sessionManager.GetSession() failed")
 69 | 		return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
 70 | 	}
 71 | 
 72 | 	headers := map[string]string{"HX-Trigger-After-Swap": "{\"parseAllRawMessages\":\"\"}"}
 73 | 	return web.RenderResponse(http.StatusOK, instance.templates, "main.gohtml", ToUiSessions(session.ChatBlocks()), headers, cookie)
 74 | }
 75 | 
 76 | func (instance *ChatHandlers) Ask(request *http.Request, simulatedDelay int) *web.Response {
 77 | 	id := cookies.GetIdFromCookie(request)
 78 | 	if id == uuid.Nil {
 79 | 		return web.GetEmptyResponse(http.StatusBadRequest, nil, nil)
 80 | 	}
 81 | 
 82 | 	session := instance.sessionManager.GetSession(id)
 83 | 	if session == nil {
 84 | 		log.Error().Msg("sessionManager.GetSession() failed")
 85 | 		return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
 86 | 	}
 87 | 
 88 | 	err := request.ParseForm()
 89 | 	if err != nil {
 90 | 		log.Error().Err(err).Msg("http.Request.ParseForm() failed")
 91 | 		return web.GetEmptyResponse(http.StatusBadRequest, nil, nil)
 92 | 	}
 93 | 
 94 | 	userInput := request.Form.Get("user-input")
 95 | 	if userInput == "" {
 96 | 		return web.GetEmptyResponse(http.StatusBadRequest, nil, nil)
 97 | 	}
 98 | 
 99 | 	// Enqueue the message to the session
100 | 	err = session.EnqueueMessage(userInput)
101 | 	if err != nil {
102 | 		log.Error().Err(err).Msg("enqueue question failed")
103 | 		return web.GetEmptyResponse(http.StatusInternalServerError, nil, nil)
104 | 	}
105 | 
106 | 	time.Sleep(time.Duration(simulatedDelay) * time.Millisecond)
107 | 
108 | 	headers := map[string]string{"HX-Trigger-After-Swap": "{\"clearUserInput\":\"\"}"}
109 | 	return web.GetEmptyResponse(http.StatusOK, headers, nil)
110 | }
111 | 
112 | func (instance *ChatHandlers) chatBlockResponseHandler(id uuid.UUID) func(response chatSession.ChatBlockResponse) {
113 | 	return func(response chatSession.ChatBlockResponse) {
114 | 		uiResponse := ToUiSessionResponse(response)
115 | 
116 | 		templateName := "chat-response.gohtml"
117 | 		var buffer bytes.Buffer
118 | 		if err := instance.templates.ExecuteTemplate(&buffer, templateName, uiResponse); err != nil {
119 | 			log.Error().Err(err).Str("template_name", templateName).Msg("templates.ExecuteTemplate() failed")
120 | 		}
121 | 		log.Debug().Str("system_message", response.ChatBlock.SystemMessage).
122 | 			Str("user_message", response.ChatBlock.UserMessage).
123 | 			Str("assistant_message", response.ChatBlock.AssistantMessage).
124 | 			Bool("completed", response.ChatBlock.Completed).
125 | 			Bool("failed", response.ChatBlock.Failed).
126 | 			Msg("ChatBlockResponse")
127 | 		instance.notificationServer.Publish(id, buffer.Bytes())
128 | 	}
129 | }
130 | 


--------------------------------------------------------------------------------
/web/frontend/main.js:
--------------------------------------------------------------------------------
  1 | import './htmx.js'
  2 | import 'htmx.org/dist/ext/ws.js'
  3 | import {marked} from 'marked'
  4 | import markedKatex from 'marked-katex-extension'
  5 | 
  6 | import "@fontsource/noto-sans/100.css"
  7 | import "@fontsource/noto-sans/200.css"
  8 | import "@fontsource/noto-sans/300.css"
  9 | import "@fontsource/noto-sans/400.css"
 10 | import "@fontsource/noto-sans/500.css"
 11 | import "@fontsource/noto-sans/600.css"
 12 | import "@fontsource/noto-sans/700.css"
 13 | import "@fontsource/noto-sans/800.css"
 14 | import "@fontsource/noto-sans/900.css"
 15 | 
 16 | import "@fontsource/noto-sans-mono/100.css"
 17 | import "@fontsource/noto-sans-mono/200.css"
 18 | import "@fontsource/noto-sans-mono/300.css"
 19 | import "@fontsource/noto-sans-mono/400.css"
 20 | import "@fontsource/noto-sans-mono/500.css"
 21 | import "@fontsource/noto-sans-mono/600.css"
 22 | import "@fontsource/noto-sans-mono/700.css"
 23 | import "@fontsource/noto-sans-mono/800.css"
 24 | import "@fontsource/noto-sans-mono/900.css"
 25 | 
 26 | import 'katex/dist/katex.min.css'
 27 | 
 28 | import './style.css'
 29 | 
 30 | const options = {
 31 |     nonStandard: false
 32 | }
 33 | 
 34 | marked.use(markedKatex(options))
 35 | 
 36 | window.chatWrapperScrollAutomatically = false
 37 | 
 38 | window.mainContentScrollToBottom = function(){
 39 |     if (window.chatWrapperScrollAutomatically === true) {
 40 |         const chatWrapper = document.querySelector(".main-content")
 41 |         chatWrapper.scrollTop = chatWrapper.scrollHeight
 42 |         window.chatWrapperScrollAutomatically = false
 43 |     }
 44 | }
 45 | 
 46 | document.body.addEventListener("htmx:oobBeforeSwap", function (evt) {
 47 |     const chatMessages = document.querySelector('#main .chat-messages')
 48 |     const lastAssistantChatMessage = document.querySelector('#main .chat-message.assistant:last-child')
 49 | 
 50 |     if (evt.detail.target === chatMessages || evt.detail.target === lastAssistantChatMessage) {
 51 |         const chatWrapper = document.querySelector(".main-content")
 52 | 
 53 |         if (Math.abs(chatWrapper.scrollHeight - chatWrapper.clientHeight - chatWrapper.scrollTop) <= 1) {
 54 |             window.chatWrapperScrollAutomatically = true
 55 |         }
 56 |     }
 57 | })
 58 | 
 59 | document.body.addEventListener("htmx:oobAfterSwap", function (evt) {
 60 |     const chatMessages = document.querySelector('#main .chat-messages')
 61 |     const lastAssistantChatMessage = document.querySelector('#main .chat-message.assistant:last-child')
 62 | 
 63 |     if (evt.detail.target === chatMessages) {
 64 |         const messages = chatMessages.querySelectorAll('.chat-message')
 65 | 
 66 |         for (const message of messages) {
 67 |             parseRawMessage(message)
 68 |         }
 69 |         window.mainContentScrollToBottom()
 70 | 
 71 |     } else if (evt.detail.target === lastAssistantChatMessage) {
 72 |         parseRawMessage(lastAssistantChatMessage)
 73 |         window.mainContentScrollToBottom()
 74 |     }
 75 | })
 76 | 
 77 | document.body.addEventListener("parseAllRawMessages", function(evt){
 78 |     const messages = document.querySelectorAll('#main .chat-message')
 79 | 
 80 |     for (const message of messages) {
 81 |         parseRawMessage(message)
 82 |     }
 83 | 
 84 |     window.chatWrapperScrollAutomatically = true
 85 |     window.mainContentScrollToBottom()
 86 | })
 87 | 
 88 | document.body.addEventListener("clearUserInput", function(evt){
 89 |     const userInput = document.querySelector('.main-footer .user-input')
 90 |     userInput.value = ''
 91 | })
 92 | 
 93 | function parseRawMessage(message) {
 94 |     const raw = message.querySelector('.raw')
 95 |     const formatted = message.querySelector('.formatted')
 96 | 
 97 |     if (formatted.innerHTML === "") {
 98 |         const s = atob(raw.innerHTML)
 99 | 
100 |         if (message.classList.contains('user')) {
101 |             formatted.innerHTML = s
102 |         } else {
103 |             // Process think tags in assistant messages
104 |             const thinkRegex = /<think>([\s\S]*?)<\/think>/g
105 | 
106 |             if (s.includes("<think>")) {
107 |                 let result = ""
108 |                 let lastIndex = 0
109 |                 let match
110 | 
111 |                 // Reset the regex to start from the beginning
112 |                 thinkRegex.lastIndex = 0
113 | 
114 |                 // Process each segment (alternating between regular and think content)
115 |                 while ((match = thinkRegex.exec(s)) !== null) {
116 |                     // Add the regular content before this think block (parsed with markdown)
117 |                     const regularContent = s.substring(lastIndex, match.index)
118 |                     if (regularContent) {
119 |                         result += marked.parse(regularContent)
120 |                     }
121 | 
122 |                     // Add the think content (parsed with markdown and wrapped in styled div)
123 |                     const thinkContent = match[1]
124 |                     result += `<div class="think-content">${marked.parse(thinkContent)}</div>`
125 | 
126 |                     // Update the last index to after this think block
127 |                     lastIndex = match.index + match[0].length
128 |                 }
129 | 
130 |                 // Add any remaining regular content after the last think block
131 |                 if (lastIndex < s.length) {
132 |                     const remainingContent = s.substring(lastIndex)
133 |                     result += marked.parse(remainingContent)
134 |                 }
135 | 
136 |                 formatted.innerHTML = result
137 |             } else {
138 |                 // No think tags, just parse the whole content with markdown
139 |                 formatted.innerHTML = marked.parse(s)
140 |             }
141 |         }
142 |     }
143 | }
144 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
  1 | module ai-chat
  2 | 
  3 | go 1.24.0
  4 | 
  5 | toolchain go1.24.4
  6 | 
  7 | require (
  8 | 	github.com/bytedance/sonic v1.13.3
  9 | 	github.com/cloudwego/eino v0.3.43
 10 | 	github.com/cloudwego/eino-ext/components/model/claude v0.0.0-20250612061754-5a3deb091dc5
 11 | 	github.com/cloudwego/eino-ext/components/model/ollama v0.0.0-20250612061754-5a3deb091dc5
 12 | 	github.com/cloudwego/eino-ext/components/model/openai v0.0.0-20250612061754-5a3deb091dc5
 13 | 	github.com/coder/websocket v1.8.13
 14 | 	github.com/getkin/kin-openapi v0.122.0
 15 | 	github.com/go-chi/chi/v5 v5.2.1
 16 | 	github.com/go-chi/cors v1.2.1
 17 | 	github.com/go-chi/httplog/v2 v2.1.1
 18 | 	github.com/google/uuid v1.6.0
 19 | 	github.com/mark3labs/mcp-go v0.32.0
 20 | 	github.com/ollama/ollama v0.5.12
 21 | 	github.com/rs/zerolog v1.34.0
 22 | 	github.com/spf13/pflag v1.0.6
 23 | 	github.com/spf13/viper v1.20.1
 24 | 	github.com/stretchr/testify v1.10.0
 25 | 	google.golang.org/genai v1.11.0
 26 | )
 27 | 
 28 | require (
 29 | 	cloud.google.com/go v0.116.0 // indirect
 30 | 	cloud.google.com/go/auth v0.13.0 // indirect
 31 | 	cloud.google.com/go/compute/metadata v0.6.0 // indirect
 32 | 	github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.8 // indirect
 33 | 	github.com/aws/aws-sdk-go-v2 v1.33.0 // indirect
 34 | 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.3 // indirect
 35 | 	github.com/aws/aws-sdk-go-v2/config v1.29.1 // indirect
 36 | 	github.com/aws/aws-sdk-go-v2/credentials v1.17.54 // indirect
 37 | 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.24 // indirect
 38 | 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.28 // indirect
 39 | 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.28 // indirect
 40 | 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
 41 | 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.1 // indirect
 42 | 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.9 // indirect
 43 | 	github.com/aws/aws-sdk-go-v2/service/sso v1.24.11 // indirect
 44 | 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.10 // indirect
 45 | 	github.com/aws/aws-sdk-go-v2/service/sts v1.33.9 // indirect
 46 | 	github.com/aws/smithy-go v1.22.1 // indirect
 47 | 	github.com/bytedance/sonic/loader v0.2.4 // indirect
 48 | 	github.com/cloudwego/base64x v0.1.5 // indirect
 49 | 	github.com/cloudwego/eino-ext/libs/acl/openai v0.0.0-20250605072634-0f875e04269d // indirect
 50 | 	github.com/davecgh/go-spew v1.1.1 // indirect
 51 | 	github.com/dustin/go-humanize v1.0.1 // indirect
 52 | 	github.com/evanphx/json-patch v0.5.2 // indirect
 53 | 	github.com/felixge/httpsnoop v1.0.4 // indirect
 54 | 	github.com/fsnotify/fsnotify v1.8.0 // indirect
 55 | 	github.com/go-logr/logr v1.4.2 // indirect
 56 | 	github.com/go-logr/stdr v1.2.2 // indirect
 57 | 	github.com/go-openapi/jsonpointer v0.19.6 // indirect
 58 | 	github.com/go-openapi/swag v0.22.4 // indirect
 59 | 	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
 60 | 	github.com/google/go-cmp v0.6.0 // indirect
 61 | 	github.com/google/s2a-go v0.1.8 // indirect
 62 | 	github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect
 63 | 	github.com/googleapis/gax-go/v2 v2.14.1 // indirect
 64 | 	github.com/goph/emperror v0.17.2 // indirect
 65 | 	github.com/gorilla/websocket v1.5.3 // indirect
 66 | 	github.com/invopop/yaml v0.2.0 // indirect
 67 | 	github.com/josharian/intern v1.0.0 // indirect
 68 | 	github.com/json-iterator/go v1.1.12 // indirect
 69 | 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 70 | 	github.com/mailru/easyjson v0.7.7 // indirect
 71 | 	github.com/mattn/go-colorable v0.1.13 // indirect
 72 | 	github.com/mattn/go-isatty v0.0.20 // indirect
 73 | 	github.com/meguminnnnnnnnn/go-openai v0.0.0-20250523041550-e202cd57070c // indirect
 74 | 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 75 | 	github.com/modern-go/reflect2 v1.0.2 // indirect
 76 | 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 77 | 	github.com/nikolalohinski/gonja v1.5.3 // indirect
 78 | 	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
 79 | 	github.com/perimeterx/marshmallow v1.1.5 // indirect
 80 | 	github.com/pkg/errors v0.9.1 // indirect
 81 | 	github.com/pmezard/go-difflib v1.0.0 // indirect
 82 | 	github.com/sagikazarmark/locafero v0.7.0 // indirect
 83 | 	github.com/sirupsen/logrus v1.9.3 // indirect
 84 | 	github.com/slongfield/pyfmt v0.0.0-20220222012616-ea85ff4c361f // indirect
 85 | 	github.com/sourcegraph/conc v0.3.0 // indirect
 86 | 	github.com/spf13/afero v1.12.0 // indirect
 87 | 	github.com/spf13/cast v1.7.1 // indirect
 88 | 	github.com/subosito/gotenv v1.6.0 // indirect
 89 | 	github.com/tidwall/gjson v1.18.0 // indirect
 90 | 	github.com/tidwall/match v1.1.1 // indirect
 91 | 	github.com/tidwall/pretty v1.2.1 // indirect
 92 | 	github.com/tidwall/sjson v1.2.5 // indirect
 93 | 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 94 | 	github.com/yargevad/filepathx v1.0.0 // indirect
 95 | 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 96 | 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect
 97 | 	go.opentelemetry.io/otel v1.29.0 // indirect
 98 | 	go.opentelemetry.io/otel/metric v1.29.0 // indirect
 99 | 	go.opentelemetry.io/otel/trace v1.29.0 // indirect
100 | 	go.uber.org/atomic v1.9.0 // indirect
101 | 	go.uber.org/multierr v1.9.0 // indirect
102 | 	golang.org/x/arch v0.11.0 // indirect
103 | 	golang.org/x/crypto v0.32.0 // indirect
104 | 	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
105 | 	golang.org/x/net v0.33.0 // indirect
106 | 	golang.org/x/sys v0.29.0 // indirect
107 | 	golang.org/x/text v0.21.0 // indirect
108 | 	google.golang.org/genproto/googleapis/rpc v0.0.0-20241223144023-3abc09e42ca8 // indirect
109 | 	google.golang.org/grpc v1.67.3 // indirect
110 | 	google.golang.org/protobuf v1.36.1 // indirect
111 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
112 | )
113 | 


--------------------------------------------------------------------------------
/cmd/ricky-bot/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/agent"
  5 | 	"ai-chat/internal/pkg/config"
  6 | 	"ai-chat/internal/pkg/httpHandlers"
  7 | 	internalConfig "ai-chat/internal/pkg/mcpConfig"
  8 | 	"ai-chat/internal/pkg/models"
  9 | 	"ai-chat/internal/pkg/sessions"
 10 | 	"ai-chat/internal/pkg/staticAssets"
 11 | 	"ai-chat/internal/pkg/web"
 12 | 	"ai-chat/internal/pkg/websocketServer"
 13 | 	webAssets "ai-chat/web"
 14 | 	"context"
 15 | 	"errors"
 16 | 	"fmt"
 17 | 	"github.com/go-chi/chi/v5"
 18 | 	"github.com/go-chi/cors"
 19 | 	"github.com/go-chi/httplog/v2"
 20 | 	"github.com/rs/zerolog"
 21 | 	"github.com/rs/zerolog/log"
 22 | 	"log/slog"
 23 | 	"net"
 24 | 	"net/http"
 25 | 	"os"
 26 | 	"os/signal"
 27 | 	"syscall"
 28 | 	"time"
 29 | )
 30 | 
 31 | // Windows configuration examples
 32 | // cmd /V /C "set HTMX_APP_PORT=321&& ricky-bot.exe"
 33 | // ricky-bot.exe --Port 123
 34 | 
 35 | // Linux configuration examples
 36 | // HTMX_APP_PORT=321 ./ricky-bot
 37 | // ./ricky-bot --Port 123
 38 | 
 39 | const applicationName = "ricky-bot"
 40 | const serverShutdownTimeout = 5 * time.Second
 41 | const embedFsRoot = "frontend/dist"
 42 | const templatesDir = "templates"
 43 | const uiUrlPrefix = "/chat"
 44 | const defaultUiUrl = "index.html"
 45 | 
 46 | func main() {
 47 | 	setupZerolog()
 48 | 
 49 | 	log.Info().Msg("Parsing configuration")
 50 | 	appConfig := &applicationConfig{}
 51 | 	config.Parse(appConfig, applicationName)
 52 | 
 53 | 	log.Info().Msg("Starting up")
 54 | 
 55 | 	templates, err := web.TemplateParseFSRecursive(webAssets.TemplateFS, templatesDir, ".gohtml", nil)
 56 | 	if err != nil {
 57 | 		log.Panic().Err(err).Msg("template parsing failed")
 58 | 	}
 59 | 
 60 | 	// Load MCP configuration
 61 | 	log.Info().Msg("Loading MCP configuration")
 62 | 	mcpConfig, err := internalConfig.LoadMCPConfig(appConfig.McpConfigFile)
 63 | 	if err != nil {
 64 | 		log.Panic().Err(err).Msg("failed to load MCP configuration")
 65 | 	}
 66 | 
 67 | 	// Create model configuration
 68 | 	modelConfig := &models.ProviderConfig{
 69 | 		ModelString:  appConfig.ModelName,
 70 | 		SystemPrompt: appConfig.SystemPrompt,
 71 | 	}
 72 | 
 73 | 	// Create agent configuration
 74 | 	agentConfig := &agent.AgentConfig{
 75 | 		ModelConfig:   modelConfig,
 76 | 		MCPConfig:     mcpConfig,
 77 | 		SystemPrompt:  appConfig.SystemPrompt,
 78 | 		MaxSteps:      appConfig.MaxSteps,
 79 | 		MessageWindow: appConfig.MessageWindow,
 80 | 	}
 81 | 
 82 | 	// Create the agent
 83 | 	ctx := context.Background()
 84 | 	mcpAgent, err := agent.NewAgent(ctx, agentConfig)
 85 | 	if err != nil {
 86 | 		log.Panic().Err(err).Msg("failed to create agent")
 87 | 	}
 88 | 	defer mcpAgent.Close()
 89 | 
 90 | 	sessionManager := sessions.New()
 91 | 	notificationServer := websocketServer.New()
 92 | 	handlers := httpHandlers.New(templates, sessionManager, notificationServer, mcpAgent)
 93 | 
 94 | 	listener := createNetListener(appConfig)
 95 | 	server := startHttpServer(listener, handlers, notificationServer, appConfig.SimulatedDelay)
 96 | 
 97 | 	done := make(chan os.Signal, 1)
 98 | 	signal.Notify(done, os.Interrupt, syscall.SIGTERM)
 99 | 	<-done
100 | 
101 | 	log.Info().Msg("Application stopping")
102 | 
103 | 	ctx, cancel := context.WithTimeout(context.Background(), serverShutdownTimeout)
104 | 	defer func() {
105 | 		cancel()
106 | 	}()
107 | 
108 | 	if err := server.Shutdown(ctx); err != nil {
109 | 		log.Fatal().Err(err).Msg("server.Shutdown failed")
110 | 	}
111 | 
112 | 	sessionManager.Shutdown()
113 | 
114 | 	time.Sleep(time.Second * 1) // Give some time for graceful shutdown
115 | 	log.Info().Msg("Application stopped")
116 | }
117 | 
118 | func startHttpServer(listener net.Listener, handlers *httpHandlers.ChatHandlers,
119 | 	notificationServer websocketServer.WebsocketServer,
120 | 	simulatedDelay int) *http.Server {
121 | 
122 | 	logger := slog.New(slog.NewJSONHandler(os.Stderr, nil))
123 | 	slog.SetDefault(logger)
124 | 
125 | 	httpLogger := httplog.NewLogger("backend-api", httplog.Options{
126 | 		LogLevel: slog.LevelDebug,
127 | 		JSON:     true,
128 | 		Concise:  true,
129 | 		//RequestHeaders:   true,
130 | 		//ResponseHeaders:  true,
131 | 	})
132 | 
133 | 	router := chi.NewRouter()
134 | 	router.Use(httplog.RequestLogger(httpLogger))
135 | 	router.Use(cors.Handler(cors.Options{
136 | 		AllowedOrigins: []string{
137 | 			"https://*",
138 | 			"http://*",
139 | 		},
140 | 	}))
141 | 
142 | 	router.Handle(uiUrlPrefix+"*", staticAssets.Handler(webAssets.EmbedFs, embedFsRoot, uiUrlPrefix, defaultUiUrl))
143 | 
144 | 	router.HandleFunc("/api/notifications", notificationServer.Handler)
145 | 
146 | 	router.Handle("POST /api/ask", web.Handler{Request: handlers.Ask,
147 | 		SimulatedDelay: simulatedDelay})
148 | 
149 | 	router.Handle("GET /api/main", web.Handler{Request: handlers.Main,
150 | 		SimulatedDelay: simulatedDelay})
151 | 
152 | 	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
153 | 		http.Redirect(w, r, uiUrlPrefix, http.StatusPermanentRedirect)
154 | 	})
155 | 
156 | 	server := &http.Server{
157 | 		Handler: router,
158 | 	}
159 | 
160 | 	go func() {
161 | 		log.Info().Msg("Server is about to start")
162 | 
163 | 		err := server.Serve(listener)
164 | 		if err != nil {
165 | 			if err != nil && !errors.Is(err, http.ErrServerClosed) {
166 | 				log.Fatal().Err(err).Msg("server.ListenAndServe failed")
167 | 			}
168 | 		}
169 | 
170 | 		log.Info().Msg("Server stopped")
171 | 	}()
172 | 	return server
173 | }
174 | 
175 | func createNetListener(appConfig *applicationConfig) net.Listener {
176 | 	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", appConfig.Host, appConfig.Port))
177 | 	if err != nil {
178 | 		log.Fatal().Err(err).Msg("net.Listen failed")
179 | 	}
180 | 
181 | 	return listener
182 | }
183 | 
184 | func setupZerolog() {
185 | 	zerolog.TimeFieldFormat = time.RFC3339Nano
186 | 	log.Logger = zerolog.New(os.Stderr).
187 | 		With().
188 | 		Timestamp().
189 | 		Logger()
190 | }
191 | 


--------------------------------------------------------------------------------
/internal/pkg/chatSession/chatSessionImpl.go:
--------------------------------------------------------------------------------
  1 | package chatSession
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"errors"
  6 | 	"github.com/ollama/ollama/api"
  7 | 	"github.com/rs/zerolog/log"
  8 | )
  9 | 
 10 | const questionQueueBufferSize = 16
 11 | 
 12 | type chatSessionImpl struct {
 13 | 	sessions            []*ChatBlock
 14 | 	tools               api.Tools
 15 | 	model               string
 16 | 	stream              bool
 17 | 	client              *api.Client
 18 | 	questions           chan string
 19 | 	exitRequested       chan any
 20 | 	sessionResponseFunc ChatBlockResponseFunc
 21 | }
 22 | 
 23 | func (instance *chatSessionImpl) ChatBlocks() []ChatBlock {
 24 | 	sessions := make([]ChatBlock, len(instance.sessions))
 25 | 	for index := range instance.sessions {
 26 | 		sessions[index] = *instance.sessions[index]
 27 | 	}
 28 | 	return sessions
 29 | }
 30 | 
 31 | func (instance *chatSessionImpl) EnqueueMessage(message string) error {
 32 | 	select {
 33 | 	case instance.questions <- message:
 34 | 		return nil
 35 | 	default:
 36 | 		return errors.New("question queue is full")
 37 | 	}
 38 | }
 39 | 
 40 | func toApiMessages(chatBlocks []*ChatBlock) []api.Message {
 41 | 	messages := make([]api.Message, 0)
 42 | 	for _, chatBlock := range chatBlocks {
 43 | 		if chatBlock.Failed {
 44 | 			continue
 45 | 		}
 46 | 
 47 | 		if chatBlock.SystemMessage != "" {
 48 | 			systemApiMessage := api.Message{
 49 | 				Role:    "system",
 50 | 				Content: chatBlock.SystemMessage,
 51 | 			}
 52 | 			messages = append(messages, systemApiMessage)
 53 | 		}
 54 | 
 55 | 		if chatBlock.UserMessage != "" {
 56 | 			userApiMessage := api.Message{
 57 | 				Role:    "user",
 58 | 				Content: chatBlock.UserMessage,
 59 | 			}
 60 | 			messages = append(messages, userApiMessage)
 61 | 		}
 62 | 
 63 | 		if chatBlock.AssistantMessage != "" {
 64 | 			assistantApiMessage := api.Message{
 65 | 				Role:    "assistant",
 66 | 				Content: chatBlock.AssistantMessage,
 67 | 			}
 68 | 			messages = append(messages, assistantApiMessage)
 69 | 		}
 70 | 	}
 71 | 	return messages
 72 | }
 73 | 
 74 | func New(responseFunc ChatBlockResponseFunc, toolsJson string) (ChatSession, error) {
 75 | 	client, err := api.ClientFromEnvironment()
 76 | 	if err != nil {
 77 | 		log.Error().Err(err).Msg("ollama api.ClientFromEnvironment() failed")
 78 | 		return nil, err
 79 | 	}
 80 | 
 81 | 	//var apiTools api.Tools
 82 | 	//if toolsJson != "" {
 83 | 	//	apiTools = api.Tools{}
 84 | 	//	err = json.Unmarshal([]byte(toolsJson), &apiTools)
 85 | 	//	if err != nil {
 86 | 	//		log.Err(err).Msg("failed to unmarshal tools json")
 87 | 	//		return nil, err
 88 | 	//	}
 89 | 	//}
 90 | 
 91 | 	chat := &chatSessionImpl{sessions: []*ChatBlock{},
 92 | 		//model: "mistral:7b",
 93 | 		model: "granite3.3:8b",
 94 | 		//model:               "llama3.2:3b",
 95 | 		stream:              true,
 96 | 		client:              client,
 97 | 		questions:           make(chan string, questionQueueBufferSize),
 98 | 		exitRequested:       make(chan any, 1),
 99 | 		sessionResponseFunc: responseFunc,
100 | 		tools:               nil}
101 | 
102 | 	go chat.questionsProcessingHandler()
103 | 
104 | 	return chat, nil
105 | }
106 | 
107 | func (instance *chatSessionImpl) processToolsResponse(toolCalls []api.ToolCall) error {
108 | 	for _, call := range toolCalls {
109 | 		log.Info().Int("call_index", call.Function.Index).Str("call_function", call.Function.Name).Msg("==== TOOL CALL ===")
110 | 	}
111 | 
112 | 	return nil
113 | }
114 | 
115 | func (instance *chatSessionImpl) askQuestion(ctx context.Context, question string) error {
116 | 	systemMessage := "You are a helpful AI assistant. Use the provided tools when necessary."
117 | 
118 | 	if len(instance.sessions) == 0 {
119 | 		systemMessage = ""
120 | 	}
121 | 
122 | 	session := ChatBlock{
123 | 		SystemMessage:    systemMessage,
124 | 		UserMessage:      question,
125 | 		AssistantMessage: "",
126 | 		Completed:        false,
127 | 		Failed:           false,
128 | 	}
129 | 
130 | 	instance.sessions = append(instance.sessions, &session)
131 | 
132 | 	instance.sessionResponseFunc(ChatBlockResponse{
133 | 		ChatBlock: session,
134 | 		New:       true,
135 | 	})
136 | 
137 | 	request := &api.ChatRequest{
138 | 		Model:    instance.model,
139 | 		Messages: toApiMessages(instance.sessions),
140 | 		Stream:   &instance.stream,
141 | 		Tools:    instance.tools,
142 | 	}
143 | 
144 | 	var messageContent string
145 | 
146 | 	respFunc := func(response api.ChatResponse) error {
147 | 		messageContent = messageContent + response.Message.Content
148 | 		session.AssistantMessage = messageContent
149 | 
150 | 		if response.Done {
151 | 			session.Completed = true
152 | 		}
153 | 
154 | 		if response.Message.ToolCalls != nil {
155 | 			instance.processToolsResponse(response.Message.ToolCalls)
156 | 		}
157 | 
158 | 		instance.sessionResponseFunc(ChatBlockResponse{
159 | 			ChatBlock: session,
160 | 			New:       false,
161 | 		})
162 | 
163 | 		return nil
164 | 	}
165 | 
166 | 	err := instance.client.Chat(ctx, request, respFunc)
167 | 	if err != nil {
168 | 		session.Failed = true
169 | 		log.Error().Err(err).Msg("ollama api.Client.chatSessionImpl() failed")
170 | 		return err
171 | 	}
172 | 
173 | 	return nil
174 | }
175 | 
176 | func (instance *chatSessionImpl) questionsProcessingHandler() {
177 | 	ctx, cancel := context.WithCancel(context.Background())
178 | 	defer cancel()
179 | 
180 | 	for {
181 | 		select {
182 | 		case question := <-instance.questions:
183 | 			go func() {
184 | 				log.Info().Str("question_content", question).Msg("processing question")
185 | 				err := instance.askQuestion(ctx, question)
186 | 				if err != nil {
187 | 					// TODO: Send notification
188 | 				}
189 | 			}()
190 | 			break
191 | 		case <-instance.exitRequested:
192 | 			log.Info().Msg("questions processing cancelled")
193 | 			return
194 | 		}
195 | 	}
196 | }
197 | 
198 | func (instance *chatSessionImpl) Shutdown() {
199 | 	select {
200 | 	case instance.exitRequested <- struct{}{}:
201 | 		log.Info().Msg("chatSessionImpl shutdown requested")
202 | 		return
203 | 	default:
204 | 		log.Info().Msg("chatSessionImpl shutdown requested again")
205 | 		return
206 | 	}
207 | }
208 | 


--------------------------------------------------------------------------------
/cmd/calculator/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/config"
  5 | 	"context"
  6 | 	"encoding/json"
  7 | 	"errors"
  8 | 	"fmt"
  9 | 	"github.com/go-chi/chi/v5"
 10 | 	"github.com/go-chi/cors"
 11 | 	"github.com/go-chi/httplog/v2"
 12 | 	"github.com/rs/zerolog"
 13 | 	"github.com/rs/zerolog/log"
 14 | 	"log/slog"
 15 | 	"net"
 16 | 	"net/http"
 17 | 	"os"
 18 | 	"os/signal"
 19 | 	"syscall"
 20 | 	"time"
 21 | )
 22 | 
 23 | const applicationName = "calculator"
 24 | const serverShutdownTimeout = 5 * time.Second
 25 | 
 26 | func main() {
 27 | 	setupZerolog()
 28 | 
 29 | 	log.Info().Msg("Parsing configuration")
 30 | 	appConfig := &applicationConfig{}
 31 | 	config.Parse(appConfig, applicationName)
 32 | 
 33 | 	log.Info().Msg("Starting up calculator service")
 34 | 
 35 | 	listener := createNetListener(appConfig)
 36 | 	server := startHttpServer(listener)
 37 | 
 38 | 	done := make(chan os.Signal, 1)
 39 | 	signal.Notify(done, os.Interrupt, syscall.SIGTERM)
 40 | 	<-done
 41 | 
 42 | 	log.Info().Msg("Application stopping")
 43 | 
 44 | 	ctx, cancel := context.WithTimeout(context.Background(), serverShutdownTimeout)
 45 | 	defer func() {
 46 | 		cancel()
 47 | 	}()
 48 | 
 49 | 	if err := server.Shutdown(ctx); err != nil {
 50 | 		log.Fatal().Err(err).Msg("server.Shutdown failed")
 51 | 	}
 52 | 
 53 | 	time.Sleep(time.Second * 1) // Give some time for graceful shutdown
 54 | 	log.Info().Msg("Application stopped")
 55 | }
 56 | 
 57 | func startHttpServer(listener net.Listener) *http.Server {
 58 | 	logger := slog.New(slog.NewJSONHandler(os.Stderr, nil))
 59 | 	slog.SetDefault(logger)
 60 | 
 61 | 	httpLogger := httplog.NewLogger("calculator-api", httplog.Options{
 62 | 		LogLevel: slog.LevelDebug,
 63 | 		JSON:     true,
 64 | 		Concise:  true,
 65 | 	})
 66 | 
 67 | 	router := chi.NewRouter()
 68 | 	router.Use(httplog.RequestLogger(httpLogger))
 69 | 	router.Use(cors.Handler(cors.Options{
 70 | 		AllowedOrigins: []string{
 71 | 			"https://*",
 72 | 			"http://*",
 73 | 		},
 74 | 	}))
 75 | 
 76 | 	// Calculator API endpoints
 77 | 	router.Route("/api/calculator", func(r chi.Router) {
 78 | 		r.Post("/add", handleAdd)
 79 | 		r.Post("/subtract", handleSubtract)
 80 | 		r.Post("/multiply", handleMultiply)
 81 | 		r.Post("/divide", handleDivide)
 82 | 	})
 83 | 
 84 | 	// Root endpoint for service info
 85 | 	router.Get("/", func(w http.ResponseWriter, r *http.Request) {
 86 | 		w.Header().Set("Content-Type", "application/json")
 87 | 		json.NewEncoder(w).Encode(map[string]string{
 88 | 			"service": "Calculator API",
 89 | 			"version": "1.0.0",
 90 | 			"endpoints": "/api/calculator/add, /api/calculator/subtract, " +
 91 | 				"/api/calculator/multiply, /api/calculator/divide",
 92 | 		})
 93 | 	})
 94 | 
 95 | 	server := &http.Server{
 96 | 		Handler: router,
 97 | 	}
 98 | 
 99 | 	go func() {
100 | 		log.Info().Msg("Server is about to start")
101 | 
102 | 		err := server.Serve(listener)
103 | 		if err != nil {
104 | 			if err != nil && !errors.Is(err, http.ErrServerClosed) {
105 | 				log.Fatal().Err(err).Msg("server.ListenAndServe failed")
106 | 			}
107 | 		}
108 | 
109 | 		log.Info().Msg("Server stopped")
110 | 	}()
111 | 	return server
112 | }
113 | 
114 | func createNetListener(appConfig *applicationConfig) net.Listener {
115 | 	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", appConfig.Host, appConfig.Port))
116 | 	if err != nil {
117 | 		log.Fatal().Err(err).Msg("net.Listen failed")
118 | 	}
119 | 
120 | 	log.Info().Str("address", listener.Addr().String()).Msg("Server listening")
121 | 	return listener
122 | }
123 | 
124 | func setupZerolog() {
125 | 	zerolog.TimeFieldFormat = time.RFC3339Nano
126 | 	log.Logger = zerolog.New(os.Stderr).
127 | 		With().
128 | 		Timestamp().
129 | 		Logger()
130 | }
131 | 
132 | // Request and response structures
133 | type CalculationRequest struct {
134 | 	A float64 `json:"a"`
135 | 	B float64 `json:"b"`
136 | }
137 | 
138 | type CalculationResponse struct {
139 | 	Result float64 `json:"result"`
140 | 	Error  string  `json:"error,omitempty"`
141 | }
142 | 
143 | // Handler functions
144 | func handleAdd(w http.ResponseWriter, r *http.Request) {
145 | 	var req CalculationRequest
146 | 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
147 | 		sendErrorResponse(w, "Invalid request format", http.StatusBadRequest)
148 | 		return
149 | 	}
150 | 
151 | 	result := req.A + req.B
152 | 	sendSuccessResponse(w, result)
153 | }
154 | 
155 | func handleSubtract(w http.ResponseWriter, r *http.Request) {
156 | 	var req CalculationRequest
157 | 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
158 | 		sendErrorResponse(w, "Invalid request format", http.StatusBadRequest)
159 | 		return
160 | 	}
161 | 
162 | 	result := req.A - req.B
163 | 	sendSuccessResponse(w, result)
164 | }
165 | 
166 | func handleMultiply(w http.ResponseWriter, r *http.Request) {
167 | 	var req CalculationRequest
168 | 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
169 | 		sendErrorResponse(w, "Invalid request format", http.StatusBadRequest)
170 | 		return
171 | 	}
172 | 
173 | 	result := req.A * req.B
174 | 	sendSuccessResponse(w, result)
175 | }
176 | 
177 | func handleDivide(w http.ResponseWriter, r *http.Request) {
178 | 	var req CalculationRequest
179 | 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
180 | 		sendErrorResponse(w, "Invalid request format", http.StatusBadRequest)
181 | 		return
182 | 	}
183 | 
184 | 	if req.B == 0 {
185 | 		sendErrorResponse(w, "Division by zero is not allowed", http.StatusBadRequest)
186 | 		return
187 | 	}
188 | 
189 | 	result := req.A / req.B
190 | 	sendSuccessResponse(w, result)
191 | }
192 | 
193 | func sendSuccessResponse(w http.ResponseWriter, result float64) {
194 | 	w.Header().Set("Content-Type", "application/json")
195 | 	w.WriteHeader(http.StatusOK)
196 | 	json.NewEncoder(w).Encode(CalculationResponse{
197 | 		Result: result,
198 | 	})
199 | }
200 | 
201 | func sendErrorResponse(w http.ResponseWriter, errMsg string, statusCode int) {
202 | 	w.Header().Set("Content-Type", "application/json")
203 | 	w.WriteHeader(statusCode)
204 | 	json.NewEncoder(w).Encode(CalculationResponse{
205 | 		Error: errMsg,
206 | 	})
207 | }
208 | 


--------------------------------------------------------------------------------
/docs/architecture.md:
--------------------------------------------------------------------------------
  1 | # AI Chat Application Architecture
  2 | 
  3 | ## Overview
  4 | 
  5 | The AI Chat application is a web-based chat interface that allows users to interact with an AI assistant. The application is built using Go for the backend and HTML/CSS/JavaScript for the frontend. It uses WebSockets for real-time communication between the client and server.
  6 | 
  7 | ## System Architecture
  8 | 
  9 | The application follows a client-server architecture with the following high-level components:
 10 | 
 11 | ```
 12 | ┌─────────────┐      HTTP/WebSocket      ┌─────────────────────────────────────┐
 13 | │             │◄─────────────────────────┤                                     │
 14 | │  Web Client │                          │           Go Web Server             │
 15 | │             │─────────────────────────►│                                     │
 16 | └─────────────┘                          └─────────────────────────────────────┘
 17 |                                                           │
 18 |                                                           │
 19 |                                                           ▼
 20 |                                          ┌─────────────────────────────────────┐
 21 |                                          │                                     │
 22 |                                          │         Session Management          │
 23 |                                          │                                     │
 24 |                                          └─────────────────────────────────────┘
 25 |                                                           │
 26 |                                                           │
 27 |                                                           ▼
 28 |                                          ┌─────────────────────────────────────┐
 29 |                                          │                                     │
 30 |                                          │          Chat Processing            │
 31 |                                          │                                     │
 32 |                                          └─────────────────────────────────────┘
 33 | ```
 34 | 
 35 | ## Component Details
 36 | 
 37 | ### Backend Components
 38 | 
 39 | 1. **HTTP Server (main.go)**
 40 |    - Initializes and configures the web server
 41 |    - Sets up routes and middleware
 42 |    - Manages server lifecycle
 43 | 
 44 | 2. **HTTP Handlers (httpHandlers)**
 45 |    - Processes HTTP requests
 46 |    - Renders templates
 47 |    - Manages user sessions via cookies
 48 |    - Handles chat message submission
 49 | 
 50 | 3. **WebSocket Server (websocketServer)**
 51 |    - Manages WebSocket connections
 52 |    - Publishes messages to specific clients
 53 |    - Enables real-time updates
 54 | 
 55 | 4. **Session Manager (sessions)**
 56 |    - Manages user sessions
 57 |    - Maps session IDs to chat sessions
 58 |    - Handles session creation and cleanup
 59 | 
 60 | 5. **Chat Session (chatSession)**
 61 |    - Represents a conversation between a user and the AI
 62 |    - Manages chat blocks (user-assistant message pairs)
 63 |    - Processes user messages and generates AI responses
 64 | 
 65 | 6. **Configuration (config)**
 66 |    - Manages application configuration
 67 |    - Handles environment variables and command-line flags
 68 | 
 69 | 7. **Static Assets (staticAssets)**
 70 |    - Serves static files (HTML, CSS, JavaScript)
 71 |    - Embeds frontend assets into the binary
 72 | 
 73 | ### Frontend Components
 74 | 
 75 | 1. **Templates (web/templates)**
 76 |    - Go HTML templates for rendering the UI
 77 |    - Includes main page and chat response templates
 78 | 
 79 | 2. **Frontend Assets (web/frontend)**
 80 |    - CSS for styling
 81 |    - JavaScript for client-side functionality
 82 |    - Static assets like images
 83 | 
 84 | ## Data Flow
 85 | 
 86 | 1. **User Interaction Flow**
 87 |    - User accesses the application via web browser
 88 |    - Server creates a new session if one doesn't exist
 89 |    - User sends a message through the web interface
 90 |    - Message is sent to the server via HTTP POST
 91 |    - Server processes the message and generates a response
 92 |    - Response is sent back to the client via WebSocket
 93 |    - Client updates the UI with the response
 94 | 
 95 | 2. **Session Management Flow**
 96 |    - User is assigned a UUID stored in a cookie
 97 |    - UUID is used to identify the user's session
 98 |    - Session manager maintains a map of active sessions
 99 |    - When a user disconnects or times out, the session is cleaned up
100 | 
101 | ## Technologies Used
102 | 
103 | 1. **Backend**
104 |    - Go (Golang) - Primary programming language
105 |    - Chi - HTTP router
106 |    - Zerolog - Logging
107 |    - HTML Templates - Server-side rendering
108 |    - WebSockets - Real-time communication
109 | 
110 | 2. **Frontend**
111 |    - HTML/CSS - Structure and styling
112 |    - JavaScript - Client-side interactivity
113 |    - Embedded assets - Packaging static files with the binary
114 | 
115 | ## Deployment Considerations
116 | 
117 | 1. **Configuration**
118 |    - The application can be configured via environment variables or command-line flags
119 |    - Key configuration options include:
120 |      - Host interface (default: localhost)
121 |      - Port (default: 8080)
122 |      - Simulated delay for testing (default: 0ms)
123 | 
124 | 2. **Scaling**
125 |    - The application uses in-memory session storage, which may need to be replaced with a distributed solution for high-scale deployments
126 |    - WebSocket connections require consideration for load balancing
127 | 
128 | 3. **Security**
129 |    - Sessions are managed via cookies
130 |    - CORS is configured to allow connections from HTTP and HTTPS origins
131 | 
132 | ## Future Enhancements
133 | 
134 | Based on the TODO items in the README:
135 | 
136 | 1. **Tools Integration** - Integration with external tools and services
137 | 2. **Session Management Improvements**:
138 |    - Session type locking
139 |    - Session timeout and scheduled cleanup
140 |    - Improved WebSocket behavior after timeout
141 | 3. **UI Enhancements**:
142 |    - Incremental updates from server
143 |    - Disable controls during server response
144 |    - Cancel answer button
145 |    - "Answering" UI spinner
146 |    - Better text formatting for user input


--------------------------------------------------------------------------------
/internal/pkg/chatSession/agentChatSession.go:
--------------------------------------------------------------------------------
  1 | package chatSession
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/agent"
  5 | 	"context"
  6 | 	"github.com/cloudwego/eino/schema"
  7 | 	"github.com/rs/zerolog/log"
  8 | 	"sync"
  9 | )
 10 | 
 11 | // AgentChatSession is an implementation of the ChatSession interface that uses agent.Agent
 12 | type AgentChatSession struct {
 13 | 	agent            *agent.Agent
 14 | 	messages         []*schema.Message
 15 | 	chatBlocks       []ChatBlock
 16 | 	responseFunc     ChatBlockResponseFunc
 17 | 	messagesMutex    sync.RWMutex
 18 | 	processingMutex  sync.Mutex
 19 | 	currentChatBlock *ChatBlock
 20 | 	exitRequested    chan struct{}
 21 | }
 22 | 
 23 | // NewAgentChatSession creates a new AgentChatSession
 24 | func NewAgentChatSession(agent *agent.Agent, responseFunc ChatBlockResponseFunc) (ChatSession, error) {
 25 | 	return &AgentChatSession{
 26 | 		agent:         agent,
 27 | 		messages:      []*schema.Message{},
 28 | 		chatBlocks:    []ChatBlock{},
 29 | 		responseFunc:  responseFunc,
 30 | 		messagesMutex: sync.RWMutex{},
 31 | 		exitRequested: make(chan struct{}, 1),
 32 | 	}, nil
 33 | }
 34 | 
 35 | // EnqueueMessage adds a user message to the chat session and processes it
 36 | func (instance *AgentChatSession) EnqueueMessage(message string) error {
 37 | 	// Create a new chat block for this message
 38 | 	chatBlock := ChatBlock{
 39 | 		UserMessage: message,
 40 | 		Completed:   false,
 41 | 		Failed:      false,
 42 | 	}
 43 | 
 44 | 	// Add the chat block to the list
 45 | 	instance.messagesMutex.Lock()
 46 | 	instance.chatBlocks = append(instance.chatBlocks, chatBlock)
 47 | 	instance.currentChatBlock = &instance.chatBlocks[len(instance.chatBlocks)-1]
 48 | 	instance.messagesMutex.Unlock()
 49 | 
 50 | 	// Send initial UI update with user message
 51 | 	instance.responseFunc(ChatBlockResponse{
 52 | 		ChatBlock: chatBlock,
 53 | 		New:       true,
 54 | 	})
 55 | 
 56 | 	// Add user message to the messages list
 57 | 	userMessage := schema.UserMessage(message)
 58 | 	instance.messagesMutex.Lock()
 59 | 	instance.messages = append(instance.messages, userMessage)
 60 | 	instance.messagesMutex.Unlock()
 61 | 
 62 | 	// Process the message with the agent in instance goroutine
 63 | 	go instance.processMessage()
 64 | 
 65 | 	return nil
 66 | }
 67 | 
 68 | // processMessage processes the current message with the agent
 69 | func (instance *AgentChatSession) processMessage() {
 70 | 	// Ensure only one message is processed at a time
 71 | 	instance.processingMutex.Lock()
 72 | 	defer instance.processingMutex.Unlock()
 73 | 
 74 | 	// Create a copy of messages to avoid race conditions
 75 | 	instance.messagesMutex.RLock()
 76 | 	messagesCopy := make([]*schema.Message, len(instance.messages))
 77 | 	copy(messagesCopy, instance.messages)
 78 | 	currentChatBlock := instance.currentChatBlock
 79 | 	instance.messagesMutex.RUnlock()
 80 | 
 81 | 	// Call the agent
 82 | 	ctx := context.Background()
 83 | 	response, err := instance.agent.GenerateWithLoop(ctx, messagesCopy,
 84 | 		// Tool call handler
 85 | 		func(toolName, toolArgs string) {
 86 | 			log.Info().Str("tool", toolName).Str("args", toolArgs).Msg("Tool call")
 87 | 		},
 88 | 		// Tool execution handler
 89 | 		func(toolName string, isStarting bool) {
 90 | 			if isStarting {
 91 | 				log.Info().Str("tool", toolName).Msg("Tool execution started")
 92 | 			} else {
 93 | 				log.Info().Str("tool", toolName).Msg("Tool execution completed")
 94 | 			}
 95 | 		},
 96 | 		// Tool result handler
 97 | 		func(toolName, toolArgs, result string, isError bool) {
 98 | 			if isError {
 99 | 				log.Error().Str("tool", toolName).Str("result", result).Msg("Tool error")
100 | 			} else {
101 | 				log.Info().Str("tool", toolName).Str("result", result).Msg("Tool result")
102 | 			}
103 | 		},
104 | 		// Response handler
105 | 		func(content string) {
106 | 			// Update the chat block with the assistant's response
107 | 			instance.messagesMutex.Lock()
108 | 			// If there's already content (from tool call), append the new content instead of overwriting
109 | 			if currentChatBlock.AssistantMessage != "" {
110 | 				//if currentChatBlock.AssistantMessage != "" && currentChatBlock.AssistantMessage != content {
111 | 				currentChatBlock.AssistantMessage = currentChatBlock.AssistantMessage + content
112 | 				//currentChatBlock.AssistantMessage = currentChatBlock.AssistantMessage + "\n\n---\n\n" + content
113 | 			} else {
114 | 				currentChatBlock.AssistantMessage = content
115 | 			}
116 | 			currentChatBlock.Completed = true
117 | 			instance.messagesMutex.Unlock()
118 | 
119 | 			// Send UI update
120 | 			instance.responseFunc(ChatBlockResponse{
121 | 				ChatBlock: *currentChatBlock,
122 | 				New:       false,
123 | 			})
124 | 		},
125 | 		// Tool call content handler
126 | 		func(content string) {
127 | 			// Update the chat block with intermediate content
128 | 			instance.messagesMutex.Lock()
129 | 			currentChatBlock.AssistantMessage = content
130 | 			instance.messagesMutex.Unlock()
131 | 
132 | 			// Send UI update
133 | 			instance.responseFunc(ChatBlockResponse{
134 | 				ChatBlock: *currentChatBlock,
135 | 				New:       false,
136 | 			})
137 | 		},
138 | 	)
139 | 
140 | 	if err != nil {
141 | 		log.Error().Err(err).Msg("Agent.GenerateWithLoop failed")
142 | 		instance.messagesMutex.Lock()
143 | 		currentChatBlock.Failed = true
144 | 		currentChatBlock.AssistantMessage = "Error: " + err.Error()
145 | 		instance.messagesMutex.Unlock()
146 | 
147 | 		// Send UI update with error
148 | 		instance.responseFunc(ChatBlockResponse{
149 | 			ChatBlock: *currentChatBlock,
150 | 			New:       false,
151 | 		})
152 | 		return
153 | 	}
154 | 
155 | 	// Add assistant response to messages
156 | 	instance.messagesMutex.Lock()
157 | 	instance.messages = append(instance.messages, response)
158 | 	instance.messagesMutex.Unlock()
159 | }
160 | 
161 | // Shutdown stops the chat session
162 | func (instance *AgentChatSession) Shutdown() {
163 | 	select {
164 | 	case instance.exitRequested <- struct{}{}:
165 | 		log.Info().Msg("AgentChatSession shutdown requested")
166 | 	default:
167 | 		log.Info().Msg("AgentChatSession shutdown already requested")
168 | 	}
169 | }
170 | 
171 | // ChatBlocks returns the chat blocks
172 | func (instance *AgentChatSession) ChatBlocks() []ChatBlock {
173 | 	instance.messagesMutex.RLock()
174 | 	defer instance.messagesMutex.RUnlock()
175 | 
176 | 	// Create a copy of the chat blocks to avoid race conditions
177 | 	chatBlocks := make([]ChatBlock, len(instance.chatBlocks))
178 | 	copy(chatBlocks, instance.chatBlocks)
179 | 
180 | 	return chatBlocks
181 | }
182 | 


--------------------------------------------------------------------------------
/internal/pkg/mcpConfig/config.go:
--------------------------------------------------------------------------------
  1 | package mcpConfig
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"github.com/spf13/viper"
  6 | 	"os"
  7 | 	"path/filepath"
  8 | )
  9 | 
 10 | // MCPServerConfig represents configuration for an MCP server
 11 | type MCPServerConfig struct {
 12 | 	Command       string   `json:"command,omitempty"`
 13 | 	Args          []string `json:"args,omitempty"`
 14 | 	URL           string   `json:"url,omitempty"`
 15 | 	Headers       []string `json:"headers,omitempty"`
 16 | 	AllowedTools  []string `json:"allowedTools,omitempty"`
 17 | 	ExcludedTools []string `json:"excludedTools,omitempty"`
 18 | }
 19 | 
 20 | // Config represents the application configuration
 21 | type Config struct {
 22 | 	MCPServers      map[string]MCPServerConfig `json:"mcpServers" yaml:"mcpServers"`
 23 | 	Model           string                     `json:"model,omitempty" yaml:"model,omitempty"`
 24 | 	MaxSteps        int                        `json:"max-steps,omitempty" yaml:"max-steps,omitempty"`
 25 | 	MessageWindow   int                        `json:"message-window,omitempty" yaml:"message-window,omitempty"`
 26 | 	Debug           bool                       `json:"debug,omitempty" yaml:"debug,omitempty"`
 27 | 	SystemPrompt    string                     `json:"system-prompt,omitempty" yaml:"system-prompt,omitempty"`
 28 | 	OpenAIAPIKey    string                     `json:"openai-api-key,omitempty" yaml:"openai-api-key,omitempty"`
 29 | 	AnthropicAPIKey string                     `json:"anthropic-api-key,omitempty" yaml:"anthropic-api-key,omitempty"`
 30 | 	GoogleAPIKey    string                     `json:"google-api-key,omitempty" yaml:"google-api-key,omitempty"`
 31 | 	OpenAIURL       string                     `json:"openai-url,omitempty" yaml:"openai-url,omitempty"`
 32 | 	AnthropicURL    string                     `json:"anthropic-url,omitempty" yaml:"anthropic-url,omitempty"`
 33 | 	Prompt          string                     `json:"prompt,omitempty" yaml:"prompt,omitempty"`
 34 | }
 35 | 
 36 | // Validate validates the configuration
 37 | func (c *Config) Validate() error {
 38 | 	for serverName, serverConfig := range c.MCPServers {
 39 | 		if len(serverConfig.AllowedTools) > 0 && len(serverConfig.ExcludedTools) > 0 {
 40 | 			return fmt.Errorf("server %s: allowedTools and excludedTools are mutually exclusive", serverName)
 41 | 		}
 42 | 	}
 43 | 	return nil
 44 | }
 45 | 
 46 | // SystemPromptConfig represents system prompt configuration
 47 | type SystemPromptConfig struct {
 48 | 	SystemPrompt string `json:"systemPrompt"`
 49 | }
 50 | 
 51 | // LoadMCPConfig loads MCP configuration from file
 52 | func LoadMCPConfig(configFile string) (*Config, error) {
 53 | 	v := viper.New()
 54 | 
 55 | 	if configFile == "" {
 56 | 		homeDir, err := os.UserHomeDir()
 57 | 		if err != nil {
 58 | 			return nil, fmt.Errorf("error getting home directory: %v", err)
 59 | 		}
 60 | 
 61 | 		// Try .mcphost files first (new format), then .mcp files (backwards compatibility)
 62 | 		configNames := []string{".mcphost", ".mcp"}
 63 | 		configTypes := []string{"yaml", "json"}
 64 | 
 65 | 		var configFound bool
 66 | 		for _, configName := range configNames {
 67 | 			for _, configType := range configTypes {
 68 | 				v.SetConfigName(configName)
 69 | 				v.SetConfigType(configType)
 70 | 				v.AddConfigPath(homeDir)
 71 | 
 72 | 				if err := v.ReadInConfig(); err == nil {
 73 | 					configFound = true
 74 | 					break
 75 | 				}
 76 | 			}
 77 | 			if configFound {
 78 | 				break
 79 | 			}
 80 | 		}
 81 | 
 82 | 		if !configFound {
 83 | 			// Create default config file
 84 | 			if err := createDefaultConfig(homeDir); err != nil {
 85 | 				// If we can't create the file, just return default config
 86 | 				return &Config{
 87 | 					MCPServers: make(map[string]MCPServerConfig),
 88 | 				}, nil
 89 | 			}
 90 | 
 91 | 			// Try to load the newly created config
 92 | 			v.SetConfigName(".mcphost")
 93 | 			v.SetConfigType("yaml")
 94 | 			v.AddConfigPath(homeDir)
 95 | 			if err := v.ReadInConfig(); err != nil {
 96 | 				// If we still can't read it, return default config
 97 | 				return &Config{
 98 | 					MCPServers: make(map[string]MCPServerConfig),
 99 | 				}, nil
100 | 			}
101 | 		}
102 | 	} else {
103 | 		// Use specified config file
104 | 		v.SetConfigFile(configFile)
105 | 		if err := v.ReadInConfig(); err != nil {
106 | 			return nil, fmt.Errorf("error reading config file: %v", err)
107 | 		}
108 | 	}
109 | 
110 | 	var config Config
111 | 	if err := v.Unmarshal(&config); err != nil {
112 | 		return nil, fmt.Errorf("error parsing config file: %v", err)
113 | 	}
114 | 
115 | 	// Validate that allowedTools and excludedTools are mutually exclusive
116 | 	if err := config.Validate(); err != nil {
117 | 		return nil, err
118 | 	}
119 | 
120 | 	return &config, nil
121 | }
122 | 
123 | // LoadSystemPrompt loads system prompt from file or returns the string directly
124 | func LoadSystemPrompt(input string) (string, error) {
125 | 	if input == "" {
126 | 		return "", nil
127 | 	}
128 | 
129 | 	// Check if input is a file that exists
130 | 	if _, err := os.Stat(input); err == nil {
131 | 		// Treat as file path
132 | 		v := viper.New()
133 | 		v.SetConfigFile(input)
134 | 
135 | 		if err := v.ReadInConfig(); err != nil {
136 | 			return "", fmt.Errorf("error reading system prompt file: %v", err)
137 | 		}
138 | 
139 | 		systemPrompt := v.GetString("systemPrompt")
140 | 		if systemPrompt == "" {
141 | 			return "", fmt.Errorf("systemPrompt field not found in config file")
142 | 		}
143 | 
144 | 		return systemPrompt, nil
145 | 	}
146 | 
147 | 	// Treat as direct string
148 | 	return input, nil
149 | }
150 | 
151 | // createDefaultConfig creates a default .mcphost.yml file in the user's home directory
152 | func createDefaultConfig(homeDir string) error {
153 | 	configPath := filepath.Join(homeDir, ".mcphost.yml")
154 | 
155 | 	// Create the file
156 | 	file, err := os.Create(configPath)
157 | 	if err != nil {
158 | 		return fmt.Errorf("error creating config file: %v", err)
159 | 	}
160 | 	defer file.Close()
161 | 
162 | 	// Write a clean YAML template
163 | 	content := `# MCPHost Configuration File
164 | # All command-line flags can be configured here
165 | 
166 | # MCP Servers configuration
167 | # Add your MCP servers here
168 | # Example:
169 | # mcpServers:
170 | #   filesystem:
171 | #     command: npx
172 | #     args: ["@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
173 | #   sqlite:
174 | #     command: uvx
175 | #     args: ["mcp-server-sqlite", "--db-path", "/tmp/example.db"]
176 | 
177 | mcpServers:
178 | 
179 | # Application settings (all optional)
180 | # model: "anthropic:claude-sonnet-4-20250514"  # Default model to use
181 | # max-steps: 20                                # Maximum agent steps (0 for unlimited)
182 | # message-window: 40                           # Number of messages to keep in context
183 | # debug: false                                 # Enable debug logging
184 | # system-prompt: "/path/to/system-prompt.json" # System prompt file
185 | 
186 | # API Configuration (can also use environment variables)
187 | # openai-api-key: "your-openai-key"
188 | # anthropic-api-key: "your-anthropic-key"  
189 | # google-api-key: "your-google-key"
190 | # openai-url: "https://api.openai.com/v1"
191 | # anthropic-url: "https://api.anthropic.com"
192 | `
193 | 
194 | 	_, err = file.WriteString(content)
195 | 	if err != nil {
196 | 		return fmt.Errorf("error writing config content: %v", err)
197 | 	}
198 | 
199 | 	return nil
200 | }
201 | 


--------------------------------------------------------------------------------
/internal/pkg/agent/agent.go:
--------------------------------------------------------------------------------
  1 | package agent
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/mcpConfig"
  5 | 	"ai-chat/internal/pkg/models"
  6 | 	"ai-chat/internal/pkg/tools"
  7 | 	"context"
  8 | 	"encoding/json"
  9 | 	"fmt"
 10 | 	"github.com/cloudwego/eino/components/model"
 11 | 	"github.com/cloudwego/eino/components/tool"
 12 | 	"github.com/cloudwego/eino/schema"
 13 | 	"github.com/mark3labs/mcp-go/mcp"
 14 | )
 15 | 
 16 | // AgentConfig is the mcpConfig for agent.
 17 | type AgentConfig struct {
 18 | 	ModelConfig   *models.ProviderConfig
 19 | 	MCPConfig     *mcpConfig.Config
 20 | 	SystemPrompt  string
 21 | 	MaxSteps      int
 22 | 	MessageWindow int
 23 | }
 24 | 
 25 | // ToolCallHandler is a function type for handling tool calls as they happen
 26 | type ToolCallHandler func(toolName, toolArgs string)
 27 | 
 28 | // ToolExecutionHandler is a function type for handling tool execution start/end
 29 | type ToolExecutionHandler func(toolName string, isStarting bool)
 30 | 
 31 | // ToolResultHandler is a function type for handling tool results
 32 | type ToolResultHandler func(toolName, toolArgs, result string, isError bool)
 33 | 
 34 | // ResponseHandler is a function type for handling LLM responses
 35 | type ResponseHandler func(content string)
 36 | 
 37 | // ToolCallContentHandler is a function type for handling content that accompanies tool calls
 38 | type ToolCallContentHandler func(content string)
 39 | 
 40 | // Agent is the agent with real-time tool call display.
 41 | type Agent struct {
 42 | 	toolManager  *tools.MCPToolManager
 43 | 	model        model.ToolCallingChatModel
 44 | 	maxSteps     int
 45 | 	systemPrompt string
 46 | }
 47 | 
 48 | // NewAgent creates an agent with MCP tool integration and real-time tool call display
 49 | func NewAgent(ctx context.Context, config *AgentConfig) (*Agent, error) {
 50 | 	// Create the LLM provider
 51 | 	model, err := models.CreateProvider(ctx, config.ModelConfig)
 52 | 	if err != nil {
 53 | 		return nil, fmt.Errorf("failed to create model provider: %v", err)
 54 | 	}
 55 | 
 56 | 	// Create and load MCP tools
 57 | 	toolManager := tools.NewMCPToolManager()
 58 | 	if err := toolManager.LoadTools(ctx, config.MCPConfig); err != nil {
 59 | 		return nil, fmt.Errorf("failed to load MCP tools: %v", err)
 60 | 	}
 61 | 
 62 | 	maxSteps := config.MaxSteps
 63 | 	if maxSteps == 0 {
 64 | 		maxSteps = 20
 65 | 	}
 66 | 
 67 | 	return &Agent{
 68 | 		toolManager:  toolManager,
 69 | 		model:        model,
 70 | 		maxSteps:     maxSteps,
 71 | 		systemPrompt: config.SystemPrompt,
 72 | 	}, nil
 73 | }
 74 | 
 75 | // GenerateWithLoop processes messages with a custom loop that displays tool calls in real-time
 76 | func (instance *Agent) GenerateWithLoop(ctx context.Context, messages []*schema.Message,
 77 | 	onToolCall ToolCallHandler, onToolExecution ToolExecutionHandler, onToolResult ToolResultHandler, onResponse ResponseHandler, onToolCallContent ToolCallContentHandler) (*schema.Message, error) {
 78 | 
 79 | 	// Create a copy of messages to avoid modifying the original
 80 | 	workingMessages := make([]*schema.Message, len(messages))
 81 | 	copy(workingMessages, messages)
 82 | 
 83 | 	// Add system prompt if provided
 84 | 	if instance.systemPrompt != "" {
 85 | 		hasSystemMessage := false
 86 | 		if len(workingMessages) > 0 && workingMessages[0].Role == schema.System {
 87 | 			hasSystemMessage = true
 88 | 		}
 89 | 
 90 | 		if !hasSystemMessage {
 91 | 			systemMsg := schema.SystemMessage(instance.systemPrompt)
 92 | 			workingMessages = append([]*schema.Message{systemMsg}, workingMessages...)
 93 | 		}
 94 | 	}
 95 | 
 96 | 	// Get available tools
 97 | 	availableTools := instance.toolManager.GetTools()
 98 | 	var toolInfos []*schema.ToolInfo
 99 | 	toolMap := make(map[string]tool.BaseTool)
100 | 
101 | 	for _, t := range availableTools {
102 | 		info, err := t.Info(ctx)
103 | 		if err != nil {
104 | 			continue
105 | 		}
106 | 		toolInfos = append(toolInfos, info)
107 | 		toolMap[info.Name] = t
108 | 	}
109 | 
110 | 	// Main loop
111 | 	for step := 0; step < instance.maxSteps; step++ {
112 | 		// Call the LLM
113 | 		response, err := instance.model.Generate(ctx, workingMessages, model.WithTools(toolInfos))
114 | 		if err != nil {
115 | 			return nil, fmt.Errorf("failed to generate response: %v", err)
116 | 		}
117 | 
118 | 		// Add response to working messages
119 | 		workingMessages = append(workingMessages, response)
120 | 
121 | 		// Check if this is a tool call or final response
122 | 		if len(response.ToolCalls) > 0 {
123 | 			// Display any content that accompanies the tool calls
124 | 			if response.Content != "" && onToolCallContent != nil {
125 | 				onToolCallContent(response.Content)
126 | 			}
127 | 
128 | 			// Handle tool calls
129 | 			for _, toolCall := range response.ToolCalls {
130 | 				// Notify about tool call
131 | 				if onToolCall != nil {
132 | 					onToolCall(toolCall.Function.Name, toolCall.Function.Arguments)
133 | 				}
134 | 
135 | 				// Execute the tool
136 | 				if selectedTool, exists := toolMap[toolCall.Function.Name]; exists {
137 | 					// Notify tool execution start
138 | 					if onToolExecution != nil {
139 | 						onToolExecution(toolCall.Function.Name, true)
140 | 					}
141 | 
142 | 					output, err := selectedTool.(tool.InvokableTool).InvokableRun(ctx, toolCall.Function.Arguments)
143 | 
144 | 					// Notify tool execution end
145 | 					if onToolExecution != nil {
146 | 						onToolExecution(toolCall.Function.Name, false)
147 | 					}
148 | 
149 | 					if err != nil {
150 | 						errorMsg := fmt.Sprintf("Tool execution error: %v", err)
151 | 						toolMessage := schema.ToolMessage(errorMsg, toolCall.ID)
152 | 						workingMessages = append(workingMessages, toolMessage)
153 | 
154 | 						if onToolResult != nil {
155 | 							onToolResult(toolCall.Function.Name, toolCall.Function.Arguments, errorMsg, true)
156 | 						}
157 | 					} else {
158 | 						// Check if this is an MCP tool response with an error
159 | 						isError := false
160 | 						if output != "" {
161 | 							var mcpResult mcp.CallToolResult
162 | 							if err := json.Unmarshal([]byte(output), &mcpResult); err == nil && mcpResult.IsError {
163 | 								isError = true
164 | 							}
165 | 						}
166 | 
167 | 						toolMessage := schema.ToolMessage(output, toolCall.ID)
168 | 						workingMessages = append(workingMessages, toolMessage)
169 | 
170 | 						if onToolResult != nil {
171 | 							onToolResult(toolCall.Function.Name, toolCall.Function.Arguments, output, isError)
172 | 						}
173 | 					}
174 | 				} else {
175 | 					errorMsg := fmt.Sprintf("Tool not found: %s", toolCall.Function.Name)
176 | 					toolMessage := schema.ToolMessage(errorMsg, toolCall.ID)
177 | 					workingMessages = append(workingMessages, toolMessage)
178 | 
179 | 					if onToolResult != nil {
180 | 						onToolResult(toolCall.Function.Name, toolCall.Function.Arguments, errorMsg, true)
181 | 					}
182 | 				}
183 | 			}
184 | 		} else {
185 | 			// This is a final response
186 | 			if onResponse != nil && response.Content != "" {
187 | 				onResponse(response.Content)
188 | 			}
189 | 			return response, nil
190 | 		}
191 | 	}
192 | 
193 | 	// If we reach here, we've exceeded max steps
194 | 	return schema.AssistantMessage("Maximum number of steps reached.", nil), nil
195 | }
196 | 
197 | // GetTools returns the list of available tools
198 | func (instance *Agent) GetTools() []tool.BaseTool {
199 | 	return instance.toolManager.GetTools()
200 | }
201 | 
202 | // Close closes the agent and cleans up resources
203 | func (instance *Agent) Close() error {
204 | 	return instance.toolManager.Close()
205 | }
206 | 


--------------------------------------------------------------------------------
/internal/pkg/tools/mcp.go:
--------------------------------------------------------------------------------
  1 | package tools
  2 | 
  3 | import (
  4 | 	"ai-chat/internal/pkg/mcpConfig"
  5 | 	"context"
  6 | 	"encoding/json"
  7 | 	"fmt"
  8 | 	"github.com/bytedance/sonic"
  9 | 	"github.com/cloudwego/eino/components/tool"
 10 | 	"github.com/cloudwego/eino/schema"
 11 | 	"github.com/getkin/kin-openapi/openapi3"
 12 | 	"github.com/mark3labs/mcp-go/client"
 13 | 	"github.com/mark3labs/mcp-go/mcp"
 14 | )
 15 | 
 16 | // MCPToolManager manages MCP tools and clients
 17 | type MCPToolManager struct {
 18 | 	clients map[string]client.MCPClient
 19 | 	tools   []tool.BaseTool
 20 | 	toolMap map[string]*toolMapping // maps prefixed tool names to their server and original name
 21 | }
 22 | 
 23 | // toolMapping stores the mapping between prefixed tool names and their original details
 24 | type toolMapping struct {
 25 | 	serverName   string
 26 | 	originalName string
 27 | 	client       client.MCPClient
 28 | }
 29 | 
 30 | // mcpToolImpl implements the eino tool interface with server prefixing
 31 | type mcpToolImpl struct {
 32 | 	info    *schema.ToolInfo
 33 | 	mapping *toolMapping
 34 | }
 35 | 
 36 | // NewMCPToolManager creates a new MCP tool manager
 37 | func NewMCPToolManager() *MCPToolManager {
 38 | 	return &MCPToolManager{
 39 | 		clients: make(map[string]client.MCPClient),
 40 | 		tools:   make([]tool.BaseTool, 0),
 41 | 		toolMap: make(map[string]*toolMapping),
 42 | 	}
 43 | }
 44 | 
 45 | // LoadTools loads tools from MCP servers based on configuration
 46 | func (m *MCPToolManager) LoadTools(ctx context.Context, config *mcpConfig.Config) error {
 47 | 	for serverName, serverConfig := range config.MCPServers {
 48 | 		client, err := m.createMCPClient(ctx, serverName, serverConfig)
 49 | 		if err != nil {
 50 | 			return fmt.Errorf("failed to create MCP client for %s: %v", serverName, err)
 51 | 		}
 52 | 
 53 | 		m.clients[serverName] = client
 54 | 
 55 | 		// Initialize the client
 56 | 		if err := m.initializeClient(ctx, client); err != nil {
 57 | 			return fmt.Errorf("failed to initialize MCP client for %s: %v", serverName, err)
 58 | 		}
 59 | 
 60 | 		// Get tools from this server
 61 | 		listResults, err := client.ListTools(ctx, mcp.ListToolsRequest{})
 62 | 		if err != nil {
 63 | 			return fmt.Errorf("failed to list tools from server %s: %v", serverName, err)
 64 | 		}
 65 | 
 66 | 		// Create name set for allowed tools
 67 | 		var nameSet map[string]struct{}
 68 | 		if len(serverConfig.AllowedTools) > 0 {
 69 | 			nameSet = make(map[string]struct{})
 70 | 			for _, name := range serverConfig.AllowedTools {
 71 | 				nameSet[name] = struct{}{}
 72 | 			}
 73 | 		}
 74 | 
 75 | 		// Convert MCP tools to eino tools with prefixed names
 76 | 		for _, mcpTool := range listResults.Tools {
 77 | 			// Filter tools based on allowedTools/excludedTools
 78 | 			if len(serverConfig.AllowedTools) > 0 {
 79 | 				if _, ok := nameSet[mcpTool.Name]; !ok {
 80 | 					continue
 81 | 				}
 82 | 			}
 83 | 
 84 | 			// Check if tool should be excluded
 85 | 			if m.shouldExcludeTool(mcpTool.Name, serverConfig) {
 86 | 				continue
 87 | 			}
 88 | 
 89 | 			// Convert schema
 90 | 			marshaledInputSchema, err := sonic.Marshal(mcpTool.InputSchema)
 91 | 			if err != nil {
 92 | 				return fmt.Errorf("conv mcp tool input schema fail(marshal): %w, tool name: %s", err, mcpTool.Name)
 93 | 			}
 94 | 			inputSchema := &openapi3.Schema{}
 95 | 			err = sonic.Unmarshal(marshaledInputSchema, inputSchema)
 96 | 			if err != nil {
 97 | 				return fmt.Errorf("conv mcp tool input schema fail(unmarshal): %w, tool name: %s", err, mcpTool.Name)
 98 | 			}
 99 | 
100 | 			// Create prefixed tool name
101 | 			prefixedName := fmt.Sprintf("%s__%s", serverName, mcpTool.Name)
102 | 
103 | 			// Create tool mapping
104 | 			mapping := &toolMapping{
105 | 				serverName:   serverName,
106 | 				originalName: mcpTool.Name,
107 | 				client:       client,
108 | 			}
109 | 			m.toolMap[prefixedName] = mapping
110 | 
111 | 			// Create eino tool
112 | 			einoTool := &mcpToolImpl{
113 | 				info: &schema.ToolInfo{
114 | 					Name:        prefixedName,
115 | 					Desc:        mcpTool.Description,
116 | 					ParamsOneOf: schema.NewParamsOneOfByOpenAPIV3(inputSchema),
117 | 				},
118 | 				mapping: mapping,
119 | 			}
120 | 
121 | 			m.tools = append(m.tools, einoTool)
122 | 		}
123 | 	}
124 | 
125 | 	return nil
126 | }
127 | 
128 | // Info returns the tool information
129 | func (t *mcpToolImpl) Info(ctx context.Context) (*schema.ToolInfo, error) {
130 | 	return t.info, nil
131 | }
132 | 
133 | // InvokableRun executes the tool by mapping back to the original name and server
134 | func (t *mcpToolImpl) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
135 | 	result, err := t.mapping.client.CallTool(ctx, mcp.CallToolRequest{
136 | 		Request: mcp.Request{
137 | 			Method: "tools/call",
138 | 		},
139 | 		Params: struct {
140 | 			Name      string    `json:"name"`
141 | 			Arguments any       `json:"arguments,omitempty"`
142 | 			Meta      *mcp.Meta `json:"_meta,omitempty"`
143 | 		}{
144 | 			Name:      t.mapping.originalName, // Use original name, not prefixed
145 | 			Arguments: json.RawMessage(argumentsInJSON),
146 | 		},
147 | 	})
148 | 	if err != nil {
149 | 		return "", fmt.Errorf("failed to call mcp tool: %w", err)
150 | 	}
151 | 
152 | 	marshaledResult, err := sonic.MarshalString(result)
153 | 	if err != nil {
154 | 		return "", fmt.Errorf("failed to marshal mcp tool result: %w", err)
155 | 	}
156 | 
157 | 	// If the MCP server returned an error, we still return the error content as the response
158 | 	// to the LLM so it can see what went wrong. The error will be shown to the user via
159 | 	// the UI callbacks, but the LLM needs to see the actual error details to continue
160 | 	// the conversation appropriately.
161 | 	return marshaledResult, nil
162 | }
163 | 
164 | // GetTools returns all loaded tools
165 | func (m *MCPToolManager) GetTools() []tool.BaseTool {
166 | 	return m.tools
167 | }
168 | 
169 | // Close closes all MCP clients
170 | func (m *MCPToolManager) Close() error {
171 | 	for name, client := range m.clients {
172 | 		if err := client.Close(); err != nil {
173 | 			return fmt.Errorf("failed to close client %s: %v", name, err)
174 | 		}
175 | 	}
176 | 	return nil
177 | }
178 | 
179 | // shouldExcludeTool determines if a tool should be excluded based on excludedTools
180 | func (m *MCPToolManager) shouldExcludeTool(toolName string, serverConfig mcpConfig.MCPServerConfig) bool {
181 | 	// If excludedTools is specified, exclude tools in the list
182 | 	if len(serverConfig.ExcludedTools) > 0 {
183 | 		for _, excludedTool := range serverConfig.ExcludedTools {
184 | 			if excludedTool == toolName {
185 | 				return true
186 | 			}
187 | 		}
188 | 	}
189 | 
190 | 	return false
191 | }
192 | 
193 | func (m *MCPToolManager) createMCPClient(ctx context.Context, serverName string, serverConfig mcpConfig.MCPServerConfig) (client.MCPClient, error) {
194 | 	if serverConfig.Command != "" {
195 | 		// STDIO client
196 | 		return client.NewStdioMCPClient(serverConfig.Command, nil, serverConfig.Args...)
197 | 	} else if serverConfig.URL != "" {
198 | 		// SSE client
199 | 		sseClient, err := client.NewSSEMCPClient(serverConfig.URL)
200 | 		if err != nil {
201 | 			return nil, err
202 | 		}
203 | 
204 | 		// Start the SSE client
205 | 		if err := sseClient.Start(ctx); err != nil {
206 | 			return nil, fmt.Errorf("failed to start SSE client: %v", err)
207 | 		}
208 | 
209 | 		return sseClient, nil
210 | 	}
211 | 
212 | 	return nil, fmt.Errorf("invalid server configuration for %s: must specify either command or url", serverName)
213 | }
214 | 
215 | func (m *MCPToolManager) initializeClient(ctx context.Context, client client.MCPClient) error {
216 | 	initRequest := mcp.InitializeRequest{}
217 | 	initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
218 | 	initRequest.Params.ClientInfo = mcp.Implementation{
219 | 		Name:    "ricky-bot",
220 | 		Version: "1.0.0",
221 | 	}
222 | 
223 | 	_, err := client.Initialize(ctx, initRequest)
224 | 	return err
225 | }
226 | 


--------------------------------------------------------------------------------
/internal/pkg/models/gemini/gemini.go:
--------------------------------------------------------------------------------
  1 | package gemini
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"encoding/json"
  6 | 	"errors"
  7 | 	"fmt"
  8 | 	"github.com/cloudwego/eino/callbacks"
  9 | 	"github.com/cloudwego/eino/components"
 10 | 	"github.com/cloudwego/eino/components/model"
 11 | 	"github.com/cloudwego/eino/schema"
 12 | 	"github.com/getkin/kin-openapi/openapi3"
 13 | 	"google.golang.org/genai"
 14 | 	"runtime/debug"
 15 | )
 16 | 
 17 | var _ model.ToolCallingChatModel = (*ChatModel)(nil)
 18 | 
 19 | // NewChatModel creates a new Gemini chat model instance
 20 | //
 21 | // Parameters:
 22 | //   - ctx: The context for the operation
 23 | //   - cfg: Configuration for the Gemini model
 24 | //
 25 | // Returns:
 26 | //   - model.ChatModel: A chat model interface implementation
 27 | //   - error: Any error that occurred during creation
 28 | //
 29 | // Example:
 30 | //
 31 | //	model, err := gemini.NewChatModel(ctx, &gemini.Config{
 32 | //	    Client: client,
 33 | //	    Model: "gemini-pro",
 34 | //	})
 35 | func NewChatModel(_ context.Context, cfg *Config) (*ChatModel, error) {
 36 | 	return &ChatModel{
 37 | 		cli:                 cfg.Client,
 38 | 		model:               cfg.Model,
 39 | 		maxTokens:           cfg.MaxTokens,
 40 | 		temperature:         cfg.Temperature,
 41 | 		topP:                cfg.TopP,
 42 | 		topK:                cfg.TopK,
 43 | 		responseSchema:      cfg.ResponseSchema,
 44 | 		enableCodeExecution: cfg.EnableCodeExecution,
 45 | 		safetySettings:      cfg.SafetySettings,
 46 | 	}, nil
 47 | }
 48 | 
 49 | // Config contains the configuration options for the Gemini model
 50 | type Config struct {
 51 | 	// Client is the Gemini API client instance
 52 | 	// Required for making API calls to Gemini
 53 | 	Client *genai.Client
 54 | 
 55 | 	// Model specifies which Gemini model to use
 56 | 	// Examples: "gemini-pro", "gemini-pro-vision", "gemini-1.5-flash"
 57 | 	Model string
 58 | 
 59 | 	// MaxTokens limits the maximum number of tokens in the response
 60 | 	// Optional. Example: maxTokens := 100
 61 | 	MaxTokens *int
 62 | 
 63 | 	// Temperature controls randomness in responses
 64 | 	// Range: [0.0, 1.0], where 0.0 is more focused and 1.0 is more creative
 65 | 	// Optional. Example: temperature := float32(0.7)
 66 | 	Temperature *float32
 67 | 
 68 | 	// TopP controls diversity via nucleus sampling
 69 | 	// Range: [0.0, 1.0], where 1.0 disables nucleus sampling
 70 | 	// Optional. Example: topP := float32(0.95)
 71 | 	TopP *float32
 72 | 
 73 | 	// TopK controls diversity by limiting the top K tokens to sample from
 74 | 	// Optional. Example: topK := int32(40)
 75 | 	TopK *int32
 76 | 
 77 | 	// ResponseSchema defines the structure for JSON responses
 78 | 	// Optional. Used when you want structured output in JSON format
 79 | 	ResponseSchema *openapi3.Schema
 80 | 
 81 | 	// EnableCodeExecution allows the model to execute code
 82 | 	// Warning: Be cautious with code execution in production
 83 | 	// Optional. Default: false
 84 | 	EnableCodeExecution bool
 85 | 
 86 | 	// SafetySettings configures content filtering for different harm categories
 87 | 	// Controls the model's filtering behavior for potentially harmful content
 88 | 	// Optional.
 89 | 	SafetySettings []*genai.SafetySetting
 90 | }
 91 | 
 92 | // options contains Gemini-specific options for model configuration
 93 | type options struct {
 94 | 	TopK           *int32
 95 | 	ResponseSchema *openapi3.Schema
 96 | }
 97 | 
 98 | type ChatModel struct {
 99 | 	cli *genai.Client
100 | 
101 | 	model               string
102 | 	maxTokens           *int
103 | 	topP                *float32
104 | 	temperature         *float32
105 | 	topK                *int32
106 | 	responseSchema      *openapi3.Schema
107 | 	tools               []*genai.Tool
108 | 	origTools           []*schema.ToolInfo
109 | 	toolChoice          *schema.ToolChoice
110 | 	enableCodeExecution bool
111 | 	safetySettings      []*genai.SafetySetting
112 | }
113 | 
114 | func (cm *ChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (message *schema.Message, err error) {
115 | 	ctx = callbacks.EnsureRunInfo(ctx, cm.GetType(), components.ComponentOfChatModel)
116 | 
117 | 	config, conf, err := cm.buildGenerateConfig(opts...)
118 | 	if err != nil {
119 | 		return nil, err
120 | 	}
121 | 
122 | 	ctx = callbacks.OnStart(ctx, &model.CallbackInput{
123 | 		Messages: input,
124 | 		Tools:    model.GetCommonOptions(&model.Options{Tools: cm.origTools}, opts...).Tools,
125 | 		Config:   conf,
126 | 	})
127 | 	defer func() {
128 | 		if err != nil {
129 | 			callbacks.OnError(ctx, err)
130 | 		}
131 | 	}()
132 | 
133 | 	if len(input) == 0 {
134 | 		return nil, fmt.Errorf("gemini input is empty")
135 | 	}
136 | 
137 | 	contents, err := cm.convertSchemaMessages(input)
138 | 	if err != nil {
139 | 		return nil, err
140 | 	}
141 | 
142 | 	result, err := cm.cli.Models.GenerateContent(ctx, cm.model, contents, config)
143 | 	if err != nil {
144 | 		return nil, fmt.Errorf("generate content failed: %w", err)
145 | 	}
146 | 
147 | 	message, err = cm.convertResponse(result)
148 | 	if err != nil {
149 | 		return nil, fmt.Errorf("convert response failed: %w", err)
150 | 	}
151 | 
152 | 	callbacks.OnEnd(ctx, cm.convertCallbackOutput(message, conf))
153 | 	return message, nil
154 | }
155 | 
156 | func (cm *ChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (result *schema.StreamReader[*schema.Message], err error) {
157 | 	ctx = callbacks.EnsureRunInfo(ctx, cm.GetType(), components.ComponentOfChatModel)
158 | 
159 | 	config, conf, err := cm.buildGenerateConfig(opts...)
160 | 	if err != nil {
161 | 		return nil, err
162 | 	}
163 | 
164 | 	ctx = callbacks.OnStart(ctx, &model.CallbackInput{
165 | 		Messages: input,
166 | 		Tools:    model.GetCommonOptions(&model.Options{Tools: cm.origTools}, opts...).Tools,
167 | 		Config:   conf,
168 | 	})
169 | 	defer func() {
170 | 		if err != nil {
171 | 			callbacks.OnError(ctx, err)
172 | 		}
173 | 	}()
174 | 
175 | 	if len(input) == 0 {
176 | 		return nil, fmt.Errorf("gemini input is empty")
177 | 	}
178 | 
179 | 	contents, err := cm.convertSchemaMessages(input)
180 | 	if err != nil {
181 | 		return nil, err
182 | 	}
183 | 
184 | 	sr, sw := schema.Pipe[*model.CallbackOutput](1)
185 | 	go func() {
186 | 		defer func() {
187 | 			panicErr := recover()
188 | 			if panicErr != nil {
189 | 				_ = sw.Send(nil, newPanicErr(panicErr, debug.Stack()))
190 | 			}
191 | 			sw.Close()
192 | 		}()
193 | 
194 | 		for resp, err := range cm.cli.Models.GenerateContentStream(ctx, cm.model, contents, config) {
195 | 			if err != nil {
196 | 				sw.Send(nil, err)
197 | 				return
198 | 			}
199 | 
200 | 			message, err := cm.convertResponse(resp)
201 | 			if err != nil {
202 | 				sw.Send(nil, err)
203 | 				return
204 | 			}
205 | 
206 | 			closed := sw.Send(cm.convertCallbackOutput(message, conf), nil)
207 | 			if closed {
208 | 				return
209 | 			}
210 | 		}
211 | 	}()
212 | 
213 | 	srList := sr.Copy(2)
214 | 	callbacks.OnEndWithStreamOutput(ctx, srList[0])
215 | 	return schema.StreamReaderWithConvert(srList[1], func(t *model.CallbackOutput) (*schema.Message, error) {
216 | 		return t.Message, nil
217 | 	}), nil
218 | }
219 | 
220 | func (cm *ChatModel) WithTools(tools []*schema.ToolInfo) (model.ToolCallingChatModel, error) {
221 | 	if len(tools) == 0 {
222 | 		return nil, errors.New("no tools to bind")
223 | 	}
224 | 	gTools, err := cm.convertToGeminiTools(tools)
225 | 	if err != nil {
226 | 		return nil, fmt.Errorf("convert to gemini tools failed: %w", err)
227 | 	}
228 | 
229 | 	tc := schema.ToolChoiceAllowed
230 | 	ncm := *cm
231 | 	ncm.toolChoice = &tc
232 | 	ncm.tools = gTools
233 | 	ncm.origTools = tools
234 | 	return &ncm, nil
235 | }
236 | 
237 | func (cm *ChatModel) BindTools(tools []*schema.ToolInfo) error {
238 | 	if len(tools) == 0 {
239 | 		return errors.New("no tools to bind")
240 | 	}
241 | 	gTools, err := cm.convertToGeminiTools(tools)
242 | 	if err != nil {
243 | 		return err
244 | 	}
245 | 
246 | 	cm.tools = gTools
247 | 	cm.origTools = tools
248 | 	tc := schema.ToolChoiceAllowed
249 | 	cm.toolChoice = &tc
250 | 	return nil
251 | }
252 | 
253 | func (cm *ChatModel) BindForcedTools(tools []*schema.ToolInfo) error {
254 | 	if len(tools) == 0 {
255 | 		return errors.New("no tools to bind")
256 | 	}
257 | 	gTools, err := cm.convertToGeminiTools(tools)
258 | 	if err != nil {
259 | 		return err
260 | 	}
261 | 
262 | 	cm.tools = gTools
263 | 	cm.origTools = tools
264 | 	tc := schema.ToolChoiceForced
265 | 	cm.toolChoice = &tc
266 | 	return nil
267 | }
268 | 
269 | func (cm *ChatModel) buildGenerateConfig(opts ...model.Option) (*genai.GenerateContentConfig, *model.Config, error) {
270 | 	commonOptions := model.GetCommonOptions(&model.Options{
271 | 		Temperature: cm.temperature,
272 | 		MaxTokens:   cm.maxTokens,
273 | 		TopP:        cm.topP,
274 | 		Tools:       nil,
275 | 		ToolChoice:  cm.toolChoice,
276 | 	}, opts...)
277 | 	geminiOptions := model.GetImplSpecificOptions(&options{
278 | 		TopK:           cm.topK,
279 | 		ResponseSchema: cm.responseSchema,
280 | 	}, opts...)
281 | 
282 | 	conf := &model.Config{}
283 | 	config := &genai.GenerateContentConfig{}
284 | 
285 | 	// Set model
286 | 	if commonOptions.Model != nil {
287 | 		conf.Model = *commonOptions.Model
288 | 	} else {
289 | 		conf.Model = cm.model
290 | 	}
291 | 
292 | 	// Set temperature
293 | 	if commonOptions.Temperature != nil {
294 | 		conf.Temperature = *commonOptions.Temperature
295 | 		config.Temperature = commonOptions.Temperature
296 | 	} else if cm.temperature != nil {
297 | 		conf.Temperature = *cm.temperature
298 | 		config.Temperature = cm.temperature
299 | 	}
300 | 
301 | 	// Set max tokens
302 | 	if commonOptions.MaxTokens != nil {
303 | 		conf.MaxTokens = *commonOptions.MaxTokens
304 | 		config.MaxOutputTokens = int32(*commonOptions.MaxTokens)
305 | 	} else if cm.maxTokens != nil {
306 | 		conf.MaxTokens = *cm.maxTokens
307 | 		config.MaxOutputTokens = int32(*cm.maxTokens)
308 | 	}
309 | 
310 | 	// Set top P
311 | 	if commonOptions.TopP != nil {
312 | 		conf.TopP = *commonOptions.TopP
313 | 		config.TopP = commonOptions.TopP
314 | 	} else if cm.topP != nil {
315 | 		conf.TopP = *cm.topP
316 | 		config.TopP = cm.topP
317 | 	}
318 | 
319 | 	// Set top K
320 | 	if geminiOptions.TopK != nil {
321 | 		config.TopK = genai.Ptr(float32(*geminiOptions.TopK))
322 | 	} else if cm.topK != nil {
323 | 		config.TopK = genai.Ptr(float32(*cm.topK))
324 | 	}
325 | 
326 | 	// Set tools
327 | 	tools := cm.tools
328 | 	if commonOptions.Tools != nil {
329 | 		var err error
330 | 		tools, err = cm.convertToGeminiTools(commonOptions.Tools)
331 | 		if err != nil {
332 | 			return nil, nil, err
333 | 		}
334 | 	}
335 | 	if len(tools) > 0 {
336 | 		config.Tools = tools
337 | 	}
338 | 
339 | 	// Set tool choice
340 | 	if commonOptions.ToolChoice != nil {
341 | 		switch *commonOptions.ToolChoice {
342 | 		case schema.ToolChoiceForbidden:
343 | 			config.ToolConfig = &genai.ToolConfig{
344 | 				FunctionCallingConfig: &genai.FunctionCallingConfig{
345 | 					Mode: genai.FunctionCallingConfigModeNone,
346 | 				},
347 | 			}
348 | 		case schema.ToolChoiceAllowed:
349 | 			config.ToolConfig = &genai.ToolConfig{
350 | 				FunctionCallingConfig: &genai.FunctionCallingConfig{
351 | 					Mode: genai.FunctionCallingConfigModeAuto,
352 | 				},
353 | 			}
354 | 		case schema.ToolChoiceForced:
355 | 			if len(tools) == 0 {
356 | 				return nil, nil, fmt.Errorf("tool choice is forced but no tools provided")
357 | 			}
358 | 			config.ToolConfig = &genai.ToolConfig{
359 | 				FunctionCallingConfig: &genai.FunctionCallingConfig{
360 | 					Mode: genai.FunctionCallingConfigModeAny,
361 | 				},
362 | 			}
363 | 		default:
364 | 			return nil, nil, fmt.Errorf("tool choice=%s not supported", *commonOptions.ToolChoice)
365 | 		}
366 | 	}
367 | 
368 | 	// Set safety settings
369 | 	if len(cm.safetySettings) > 0 {
370 | 		config.SafetySettings = cm.safetySettings
371 | 	}
372 | 
373 | 	// Set response schema for JSON mode
374 | 	if geminiOptions.ResponseSchema != nil {
375 | 		gSchema, err := cm.convertOpenAPISchema(geminiOptions.ResponseSchema)
376 | 		if err != nil {
377 | 			return nil, nil, fmt.Errorf("convert response schema failed: %w", err)
378 | 		}
379 | 		config.ResponseMIMEType = "application/json"
380 | 		config.ResponseSchema = gSchema
381 | 	}
382 | 
383 | 	return config, conf, nil
384 | }
385 | 
386 | func (cm *ChatModel) convertToGeminiTools(tools []*schema.ToolInfo) ([]*genai.Tool, error) {
387 | 	if len(tools) == 0 {
388 | 		return nil, nil
389 | 	}
390 | 
391 | 	var functionDeclarations []*genai.FunctionDeclaration
392 | 	for _, tool := range tools {
393 | 		openSchema, err := tool.ToOpenAPIV3()
394 | 		if err != nil {
395 | 			return nil, fmt.Errorf("get open schema failed: %w", err)
396 | 		}
397 | 
398 | 		gSchema, err := cm.convertOpenAPISchema(openSchema)
399 | 		if err != nil {
400 | 			return nil, fmt.Errorf("convert open schema failed: %w", err)
401 | 		}
402 | 
403 | 		funcDecl := &genai.FunctionDeclaration{
404 | 			Name:        tool.Name,
405 | 			Description: tool.Desc,
406 | 			Parameters:  gSchema,
407 | 		}
408 | 		functionDeclarations = append(functionDeclarations, funcDecl)
409 | 	}
410 | 
411 | 	return []*genai.Tool{{FunctionDeclarations: functionDeclarations}}, nil
412 | }
413 | 
414 | func (cm *ChatModel) convertOpenAPISchema(schema *openapi3.Schema) (*genai.Schema, error) {
415 | 	if schema == nil {
416 | 		return nil, nil
417 | 	}
418 | 
419 | 	result := &genai.Schema{
420 | 		Description: schema.Description,
421 | 	}
422 | 
423 | 	switch schema.Type {
424 | 	case openapi3.TypeObject:
425 | 		result.Type = genai.TypeObject
426 | 		if schema.Properties != nil {
427 | 			properties := make(map[string]*genai.Schema)
428 | 			for name, prop := range schema.Properties {
429 | 				if prop == nil || prop.Value == nil {
430 | 					continue
431 | 				}
432 | 				propSchema, err := cm.convertOpenAPISchema(prop.Value)
433 | 				if err != nil {
434 | 					return nil, err
435 | 				}
436 | 				properties[name] = propSchema
437 | 			}
438 | 			result.Properties = properties
439 | 		}
440 | 		if schema.Required != nil {
441 | 			result.Required = schema.Required
442 | 		}
443 | 	case openapi3.TypeArray:
444 | 		result.Type = genai.TypeArray
445 | 		if schema.Items != nil && schema.Items.Value != nil {
446 | 			itemSchema, err := cm.convertOpenAPISchema(schema.Items.Value)
447 | 			if err != nil {
448 | 				return nil, err
449 | 			}
450 | 			result.Items = itemSchema
451 | 		}
452 | 	case openapi3.TypeString:
453 | 		result.Type = genai.TypeString
454 | 		if schema.Enum != nil {
455 | 			enums := make([]string, 0, len(schema.Enum))
456 | 			for _, e := range schema.Enum {
457 | 				if str, ok := e.(string); ok {
458 | 					enums = append(enums, str)
459 | 				} else {
460 | 					return nil, fmt.Errorf("enum value must be a string, schema: %+v", schema)
461 | 				}
462 | 			}
463 | 			result.Enum = enums
464 | 		}
465 | 	case openapi3.TypeNumber:
466 | 		result.Type = genai.TypeNumber
467 | 	case openapi3.TypeInteger:
468 | 		result.Type = genai.TypeInteger
469 | 	case openapi3.TypeBoolean:
470 | 		result.Type = genai.TypeBoolean
471 | 	default:
472 | 		result.Type = genai.TypeUnspecified
473 | 	}
474 | 
475 | 	return result, nil
476 | }
477 | 
478 | func (cm *ChatModel) convertSchemaMessages(messages []*schema.Message) ([]*genai.Content, error) {
479 | 	var contents []*genai.Content
480 | 	for _, message := range messages {
481 | 		content, err := cm.convertSchemaMessage(message)
482 | 		if err != nil {
483 | 			return nil, fmt.Errorf("convert schema message failed: %w", err)
484 | 		}
485 | 		if content != nil {
486 | 			contents = append(contents, content)
487 | 		}
488 | 	}
489 | 	return contents, nil
490 | }
491 | 
492 | func (cm *ChatModel) convertSchemaMessage(message *schema.Message) (*genai.Content, error) {
493 | 	if message == nil {
494 | 		return nil, nil
495 | 	}
496 | 
497 | 	var parts []*genai.Part
498 | 
499 | 	// Handle tool calls
500 | 	if message.ToolCalls != nil {
501 | 		for _, call := range message.ToolCalls {
502 | 			var args map[string]any
503 | 			if err := json.Unmarshal([]byte(call.Function.Arguments), &args); err != nil {
504 | 				return nil, fmt.Errorf("unmarshal tool call arguments failed: %w", err)
505 | 			}
506 | 			parts = append(parts, &genai.Part{
507 | 				FunctionCall: &genai.FunctionCall{
508 | 					Name: call.Function.Name,
509 | 					Args: args,
510 | 				},
511 | 			})
512 | 		}
513 | 	}
514 | 
515 | 	// Handle tool responses
516 | 	if message.Role == schema.Tool {
517 | 		var response map[string]any
518 | 		if err := json.Unmarshal([]byte(message.Content), &response); err != nil {
519 | 			// If the content is not valid JSON, treat it as a plain text error response
520 | 			response = map[string]any{
521 | 				"error": message.Content,
522 | 			}
523 | 		}
524 | 		parts = append(parts, &genai.Part{
525 | 			FunctionResponse: &genai.FunctionResponse{
526 | 				Name:     message.ToolCallID,
527 | 				Response: response,
528 | 			},
529 | 		})
530 | 	} else {
531 | 		// Handle text content
532 | 		if message.Content != "" {
533 | 			parts = append(parts, &genai.Part{Text: message.Content})
534 | 		}
535 | 
536 | 		// Handle multi-content (images, audio, etc.)
537 | 		for _, content := range message.MultiContent {
538 | 			switch content.Type {
539 | 			case schema.ChatMessagePartTypeText:
540 | 				parts = append(parts, &genai.Part{Text: content.Text})
541 | 			case schema.ChatMessagePartTypeImageURL:
542 | 				if content.ImageURL != nil {
543 | 					parts = append(parts, &genai.Part{
544 | 						FileData: &genai.FileData{
545 | 							MIMEType: content.ImageURL.MIMEType,
546 | 							FileURI:  content.ImageURL.URI,
547 | 						},
548 | 					})
549 | 				}
550 | 			case schema.ChatMessagePartTypeAudioURL:
551 | 				if content.AudioURL != nil {
552 | 					parts = append(parts, &genai.Part{
553 | 						FileData: &genai.FileData{
554 | 							MIMEType: content.AudioURL.MIMEType,
555 | 							FileURI:  content.AudioURL.URI,
556 | 						},
557 | 					})
558 | 				}
559 | 			case schema.ChatMessagePartTypeVideoURL:
560 | 				if content.VideoURL != nil {
561 | 					parts = append(parts, &genai.Part{
562 | 						FileData: &genai.FileData{
563 | 							MIMEType: content.VideoURL.MIMEType,
564 | 							FileURI:  content.VideoURL.URI,
565 | 						},
566 | 					})
567 | 				}
568 | 			case schema.ChatMessagePartTypeFileURL:
569 | 				if content.FileURL != nil {
570 | 					parts = append(parts, &genai.Part{
571 | 						FileData: &genai.FileData{
572 | 							MIMEType: content.FileURL.MIMEType,
573 | 							FileURI:  content.FileURL.URI,
574 | 						},
575 | 					})
576 | 				}
577 | 			}
578 | 		}
579 | 	}
580 | 
581 | 	if len(parts) == 0 {
582 | 		return nil, nil
583 | 	}
584 | 
585 | 	return &genai.Content{
586 | 		Role:  string(cm.convertRole(message.Role)),
587 | 		Parts: parts,
588 | 	}, nil
589 | }
590 | 
591 | func (cm *ChatModel) convertRole(role schema.RoleType) genai.Role {
592 | 	switch role {
593 | 	case schema.Assistant:
594 | 		return genai.RoleModel
595 | 	case schema.User:
596 | 		return genai.RoleUser
597 | 	case schema.Tool:
598 | 		return genai.RoleUser // Tool responses are treated as user messages in the new API
599 | 	default:
600 | 		return genai.RoleUser
601 | 	}
602 | }
603 | 
604 | func (cm *ChatModel) convertResponse(resp *genai.GenerateContentResponse) (*schema.Message, error) {
605 | 	if len(resp.Candidates) == 0 {
606 | 		return nil, fmt.Errorf("gemini result is empty")
607 | 	}
608 | 
609 | 	candidate := resp.Candidates[0]
610 | 	message := &schema.Message{
611 | 		Role: schema.Assistant,
612 | 		ResponseMeta: &schema.ResponseMeta{
613 | 			FinishReason: string(candidate.FinishReason),
614 | 		},
615 | 	}
616 | 
617 | 	// Handle usage metadata
618 | 	if resp.UsageMetadata != nil {
619 | 		message.ResponseMeta.Usage = &schema.TokenUsage{
620 | 			PromptTokens:     int(resp.UsageMetadata.PromptTokenCount),
621 | 			CompletionTokens: int(resp.UsageMetadata.CandidatesTokenCount),
622 | 			TotalTokens:      int(resp.UsageMetadata.TotalTokenCount),
623 | 		}
624 | 	}
625 | 
626 | 	// Process content parts
627 | 	var textParts []string
628 | 	for _, part := range candidate.Content.Parts {
629 | 		switch {
630 | 		case part.Text != "":
631 | 			textParts = append(textParts, part.Text)
632 | 		case part.FunctionCall != nil:
633 | 			args, err := json.Marshal(part.FunctionCall.Args)
634 | 			if err != nil {
635 | 				return nil, fmt.Errorf("marshal function call arguments failed: %w", err)
636 | 			}
637 | 			message.ToolCalls = append(message.ToolCalls, schema.ToolCall{
638 | 				ID: part.FunctionCall.Name,
639 | 				Function: schema.FunctionCall{
640 | 					Name:      part.FunctionCall.Name,
641 | 					Arguments: string(args),
642 | 				},
643 | 			})
644 | 		case part.ExecutableCode != nil:
645 | 			textParts = append(textParts, part.ExecutableCode.Code)
646 | 		case part.CodeExecutionResult != nil:
647 | 			textParts = append(textParts, part.CodeExecutionResult.Output)
648 | 		}
649 | 	}
650 | 
651 | 	// Set content
652 | 	if len(textParts) == 1 {
653 | 		message.Content = textParts[0]
654 | 	} else if len(textParts) > 1 {
655 | 		for _, text := range textParts {
656 | 			message.MultiContent = append(message.MultiContent, schema.ChatMessagePart{
657 | 				Type: schema.ChatMessagePartTypeText,
658 | 				Text: text,
659 | 			})
660 | 		}
661 | 	}
662 | 
663 | 	return message, nil
664 | }
665 | 
666 | func (cm *ChatModel) convertCallbackOutput(message *schema.Message, conf *model.Config) *model.CallbackOutput {
667 | 	callbackOutput := &model.CallbackOutput{
668 | 		Message: message,
669 | 		Config:  conf,
670 | 	}
671 | 	if message.ResponseMeta != nil && message.ResponseMeta.Usage != nil {
672 | 		callbackOutput.TokenUsage = &model.TokenUsage{
673 | 			PromptTokens:     message.ResponseMeta.Usage.PromptTokens,
674 | 			CompletionTokens: message.ResponseMeta.Usage.CompletionTokens,
675 | 			TotalTokens:      message.ResponseMeta.Usage.TotalTokens,
676 | 		}
677 | 	}
678 | 	return callbackOutput
679 | }
680 | 
681 | func (cm *ChatModel) IsCallbacksEnabled() bool {
682 | 	return true
683 | }
684 | 
685 | const typ = "Gemini"
686 | 
687 | func (cm *ChatModel) GetType() string {
688 | 	return typ
689 | }
690 | 
691 | type panicErr struct {
692 | 	info  any
693 | 	stack []byte
694 | }
695 | 
696 | func (p *panicErr) Error() string {
697 | 	return fmt.Sprintf("panic error: %v, \nstack: %s", p.info, string(p.stack))
698 | }
699 | 
700 | func newPanicErr(info any, stack []byte) error {
701 | 	return &panicErr{
702 | 		info:  info,
703 | 		stack: stack,
704 | 	}
705 | }
706 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
  1 | cloud.google.com/go v0.116.0 h1:B3fRrSDkLRt5qSHWe40ERJvhvnQwdZiHu0bJOpldweE=
  2 | cloud.google.com/go v0.116.0/go.mod h1:cEPSRWPzZEswwdr9BxE6ChEn01dWlTaF05LiC2Xs70U=
  3 | cloud.google.com/go/auth v0.13.0 h1:8Fu8TZy167JkW8Tj3q7dIkr2v4cndv41ouecJx0PAHs=
  4 | cloud.google.com/go/auth v0.13.0/go.mod h1:COOjD9gwfKNKz+IIduatIhYJQIc0mG3H102r/EMxX6Q=
  5 | cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I=
  6 | cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg=
  7 | github.com/airbrake/gobrake v3.6.1+incompatible/go.mod h1:wM4gu3Cn0W0K7GUuVWnlXZU11AGBXMILnrdOU8Kn00o=
  8 | github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.8 h1:ss/c/eeyILgoK2sMsTJdcdLdhY3wZSt//+nanM41B9w=
  9 | github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.8/go.mod h1:GJxtdOs9K4neo8Gg65CjJ7jNautmldGli5/OFNabOoo=
 10 | github.com/aws/aws-sdk-go-v2 v1.33.0 h1:Evgm4DI9imD81V0WwD+TN4DCwjUMdc94TrduMLbgZJs=
 11 | github.com/aws/aws-sdk-go-v2 v1.33.0/go.mod h1:P5WJBrYqqbWVaOxgH0X/FYYD47/nooaPOZPlQdmiN2U=
 12 | github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.3 h1:tW1/Rkad38LA15X4UQtjXZXNKsCgkshC3EbmcUmghTg=
 13 | github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.3/go.mod h1:UbnqO+zjqk3uIt9yCACHJ9IVNhyhOCnYk8yA19SAWrM=
 14 | github.com/aws/aws-sdk-go-v2/config v1.29.1 h1:JZhGawAyZ/EuJeBtbQYnaoftczcb2drR2Iq36Wgz4sQ=
 15 | github.com/aws/aws-sdk-go-v2/config v1.29.1/go.mod h1:7bR2YD5euaxBhzt2y/oDkt3uNRb6tjFp98GlTFueRwk=
 16 | github.com/aws/aws-sdk-go-v2/credentials v1.17.54 h1:4UmqeOqJPvdvASZWrKlhzpRahAulBfyTJQUaYy4+hEI=
 17 | github.com/aws/aws-sdk-go-v2/credentials v1.17.54/go.mod h1:RTdfo0P0hbbTxIhmQrOsC/PquBZGabEPnCaxxKRPSnI=
 18 | github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.24 h1:5grmdTdMsovn9kPZPI23Hhvp0ZyNm5cRO+IZFIYiAfw=
 19 | github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.24/go.mod h1:zqi7TVKTswH3Ozq28PkmBmgzG1tona7mo9G2IJg4Cis=
 20 | github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.28 h1:igORFSiH3bfq4lxKFkTSYDhJEUCYo6C8VKiWJjYwQuQ=
 21 | github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.28/go.mod h1:3So8EA/aAYm36L7XIvCVwLa0s5N0P7o2b1oqnx/2R4g=
 22 | github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.28 h1:1mOW9zAUMhTSrMDssEHS/ajx8JcAj/IcftzcmNlmVLI=
 23 | github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.28/go.mod h1:kGlXVIWDfvt2Ox5zEaNglmq0hXPHgQFNMix33Tw22jA=
 24 | github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 h1:VaRN3TlFdd6KxX1x3ILT5ynH6HvKgqdiXoTxAF4HQcQ=
 25 | github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
 26 | github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.1 h1:iXtILhvDxB6kPvEXgsDhGaZCSC6LQET5ZHSdJozeI0Y=
 27 | github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.1/go.mod h1:9nu0fVANtYiAePIBh2/pFUSwtJ402hLnp854CNoDOeE=
 28 | github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.9 h1:TQmKDyETFGiXVhZfQ/I0cCFziqqX58pi4tKJGYGFSz0=
 29 | github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.9/go.mod h1:HVLPK2iHQBUx7HfZeOQSEu3v2ubZaAY2YPbAm5/WUyY=
 30 | github.com/aws/aws-sdk-go-v2/service/sso v1.24.11 h1:kuIyu4fTT38Kj7YCC7ouNbVZSSpqkZ+LzIfhCr6Dg+I=
 31 | github.com/aws/aws-sdk-go-v2/service/sso v1.24.11/go.mod h1:Ro744S4fKiCCuZECXgOi760TiYylUM8ZBf6OGiZzJtY=
 32 | github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.10 h1:l+dgv/64iVlQ3WsBbnn+JSbkj01jIi+SM0wYsj3y/hY=
 33 | github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.10/go.mod h1:Fzsj6lZEb8AkTE5S68OhcbBqeWPsR8RnGuKPr8Todl8=
 34 | github.com/aws/aws-sdk-go-v2/service/sts v1.33.9 h1:BRVDbewN6VZcwr+FBOszDKvYeXY1kJ+GGMCcpghlw0U=
 35 | github.com/aws/aws-sdk-go-v2/service/sts v1.33.9/go.mod h1:f6vjfZER1M17Fokn0IzssOTMT2N8ZSq+7jnNF0tArvw=
 36 | github.com/aws/smithy-go v1.22.1 h1:/HPHZQ0g7f4eUeK6HKglFz8uwVfZKgoI25rb/J+dnro=
 37 | github.com/aws/smithy-go v1.22.1/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 38 | github.com/bitly/go-simplejson v0.5.0/go.mod h1:cXHtHw4XUPsvGaxgjIAn8PhEWG9NfngEKAMDJEczWVA=
 39 | github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
 40 | github.com/bugsnag/bugsnag-go v1.4.0/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8=
 41 | github.com/bugsnag/panicwrap v1.2.0/go.mod h1:D/8v3kj0zr8ZAKg1AQ6crr+5VwKN5eIywRkfhyM/+dE=
 42 | github.com/bytedance/mockey v1.2.13 h1:jokWZAm/pUEbD939Rhznz615MKUCZNuvCFQlJ2+ntoo=
 43 | github.com/bytedance/mockey v1.2.13/go.mod h1:1BPHF9sol5R1ud/+0VEHGQq/+i2lN+GTsr3O2Q9IENY=
 44 | github.com/bytedance/sonic v1.13.3 h1:MS8gmaH16Gtirygw7jV91pDCN33NyMrPbN7qiYhEsF0=
 45 | github.com/bytedance/sonic v1.13.3/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 46 | github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 47 | github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
 48 | github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
 49 | github.com/certifi/gocertifi v0.0.0-20190105021004-abcd57078448/go.mod h1:GJKEexRPVJrBSOjoqN5VNOIKJ5Q3RViH6eu3puDRwx4=
 50 | github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
 51 | github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 52 | github.com/cloudwego/eino v0.3.43 h1:mXtfnZjBAQuW8e4OKNX2dYbJxq9UNT9Vynow3NV1CZI=
 53 | github.com/cloudwego/eino v0.3.43/go.mod h1:wUjz990apdsaOraOXdh6CdhVXq8DJsOvLsVlxNTcNfY=
 54 | github.com/cloudwego/eino-ext/components/model/claude v0.0.0-20250612061754-5a3deb091dc5 h1:QyaAv3od+cuuiibj4Z15q3Xtn5OYgxL7UADBV0tC8gI=
 55 | github.com/cloudwego/eino-ext/components/model/claude v0.0.0-20250612061754-5a3deb091dc5/go.mod h1:IhvvyyldQVIyOogbEbmmOjrxhZbpvbwjeiQJ4ZoNOX4=
 56 | github.com/cloudwego/eino-ext/components/model/ollama v0.0.0-20250612061754-5a3deb091dc5 h1:lK8uyx2wL8iXgEHMRlq5z5fE9Mow8gOTU2yB8elFSTo=
 57 | github.com/cloudwego/eino-ext/components/model/ollama v0.0.0-20250612061754-5a3deb091dc5/go.mod h1:giNUFqA+V7xrm/EDvH7JFnDqoWI+e2m1SVAnReU+Fd8=
 58 | github.com/cloudwego/eino-ext/components/model/openai v0.0.0-20250612061754-5a3deb091dc5 h1:Zq3N8WOLofVrwb3oAIvNVyhFyj+K8v2Fp237xhjUQuo=
 59 | github.com/cloudwego/eino-ext/components/model/openai v0.0.0-20250612061754-5a3deb091dc5/go.mod h1:DRjlcqCwf2tLgxkBwQz6FX3OzM/sGqDN5xWYbq/ssqY=
 60 | github.com/cloudwego/eino-ext/libs/acl/openai v0.0.0-20250605072634-0f875e04269d h1:dh7XwH6UAXXH9GQ4NTg4FRmek2tCoQgBGI79vYzwm9g=
 61 | github.com/cloudwego/eino-ext/libs/acl/openai v0.0.0-20250605072634-0f875e04269d/go.mod h1:XKWiwOSkHWN23yd14et8A9khSKSYACU0xu4caySDA5U=
 62 | github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 63 | github.com/coder/websocket v1.8.13 h1:f3QZdXy7uGVz+4uCJy2nTZyM0yTBj8yANEHhqlXZ9FE=
 64 | github.com/coder/websocket v1.8.13/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
 65 | github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 66 | github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 67 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 68 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 69 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 70 | github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 71 | github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 72 | github.com/evanphx/json-patch v0.5.2 h1:xVCHIVMUu1wtM/VkR9jVZ45N3FhZfYMMYGorLCR8P3k=
 73 | github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ=
 74 | github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 75 | github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 76 | github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 77 | github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 78 | github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 79 | github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/8M=
 80 | github.com/fsnotify/fsnotify v1.8.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 81 | github.com/getkin/kin-openapi v0.122.0 h1:WB9Jbl0Hp/T79/JF9xlSW5Kl9uYdk/AWD0yAd9HOM10=
 82 | github.com/getkin/kin-openapi v0.122.0/go.mod h1:PCWw/lfBrJY4HcdqE3jj+QFkaFK8ABoqo7PvqVhXXqw=
 83 | github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ=
 84 | github.com/go-check/check v0.0.0-20180628173108-788fd7840127 h1:0gkP6mzaMqkmpcJYCFOLkIBwI7xFExG03bbkOkCvUPI=
 85 | github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
 86 | github.com/go-chi/chi/v5 v5.2.1 h1:KOIHODQj58PmL80G2Eak4WdvUzjSJSm0vG72crDCqb8=
 87 | github.com/go-chi/chi/v5 v5.2.1/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 88 | github.com/go-chi/cors v1.2.1 h1:xEC8UT3Rlp2QuWNEr4Fs/c2EAGVKBwy/1vHx3bppil4=
 89 | github.com/go-chi/cors v1.2.1/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58=
 90 | github.com/go-chi/httplog/v2 v2.1.1 h1:ojojiu4PIaoeJ/qAO4GWUxJqvYUTobeo7zmuHQJAxRk=
 91 | github.com/go-chi/httplog/v2 v2.1.1/go.mod h1:/XXdxicJsp4BA5fapgIC3VuTD+z0Z/VzukoB3VDc1YE=
 92 | github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 93 | github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 94 | github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 95 | github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 96 | github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 97 | github.com/go-openapi/jsonpointer v0.19.6 h1:eCs3fxoIi3Wh6vtgmLTOjdhSpiqphQ+DaPn38N2ZdrE=
 98 | github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs=
 99 | github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
100 | github.com/go-openapi/swag v0.22.4 h1:QLMzNJnMGPRNDCbySlcj1x01tzU8/9LTTL9hZZZogBU=
101 | github.com/go-openapi/swag v0.22.4/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
102 | github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM=
103 | github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
104 | github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
105 | github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
106 | github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
107 | github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
108 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
109 | github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
110 | github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
111 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
112 | github.com/google/s2a-go v0.1.8 h1:zZDs9gcbt9ZPLV0ndSyQk6Kacx2g/X+SKYovpnz3SMM=
113 | github.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA=
114 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
115 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
116 | github.com/googleapis/enterprise-certificate-proxy v0.3.4 h1:XYIDZApgAnrN1c855gTgghdIA6Stxb52D5RnLI1SLyw=
117 | github.com/googleapis/enterprise-certificate-proxy v0.3.4/go.mod h1:YKe7cfqYXjKGpGvmSg28/fFvhNzinZQm8DGnaburhGA=
118 | github.com/googleapis/gax-go/v2 v2.14.1 h1:hb0FFeiPaQskmvakKu5EbCbpntQn48jyHuvrkurSS/Q=
119 | github.com/googleapis/gax-go/v2 v2.14.1/go.mod h1:Hb/NubMaVM88SrNkvl8X/o8XWwDJEPqouaLeN2IUxoA=
120 | github.com/goph/emperror v0.17.2 h1:yLapQcmEsO0ipe9p5TaN22djm3OFV/TfM/fcYP0/J18=
121 | github.com/goph/emperror v0.17.2/go.mod h1:+ZbQ+fUNO/6FNiUo0ujtMjhgad9Xa6fQL9KhH4LNHic=
122 | github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
123 | github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
124 | github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
125 | github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
126 | github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
127 | github.com/invopop/yaml v0.2.0 h1:7zky/qH+O0DwAyoobXUqvVBwgBFRxKoQ/3FjcVpjTMY=
128 | github.com/invopop/yaml v0.2.0/go.mod h1:2XuRLgs/ouIrW3XNzuNj7J3Nvu/Dig5MXvbCEdiBN3Q=
129 | github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
130 | github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
131 | github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
132 | github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
133 | github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
134 | github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
135 | github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
136 | github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
137 | github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
138 | github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
139 | github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
140 | github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
141 | github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
142 | github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
143 | github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
144 | github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
145 | github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
146 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
147 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
148 | github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
149 | github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
150 | github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
151 | github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
152 | github.com/mark3labs/mcp-go v0.32.0 h1:fgwmbfL2gbd67obg57OfV2Dnrhs1HtSdlY/i5fn7MU8=
153 | github.com/mark3labs/mcp-go v0.32.0/go.mod h1:rXqOudj/djTORU/ThxYx8fqEVj/5pvTuuebQ2RC7uk4=
154 | github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
155 | github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
156 | github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
157 | github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
158 | github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
159 | github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
160 | github.com/meguminnnnnnnnn/go-openai v0.0.0-20250523041550-e202cd57070c h1:9OlRW8yJipcpKrH2c5mU5q57bDFQLW47Onp6HKHoFMQ=
161 | github.com/meguminnnnnnnnn/go-openai v0.0.0-20250523041550-e202cd57070c/go.mod h1:CqSFsV6AkkL2fixd25WYjRAolns+gQrY1x/Cz9c30v8=
162 | github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
163 | github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
164 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
165 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
166 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
167 | github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
168 | github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
169 | github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
170 | github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
171 | github.com/nikolalohinski/gonja v1.5.3 h1:GsA+EEaZDZPGJ8JtpeGN78jidhOlxeJROpqMT9fTj9c=
172 | github.com/nikolalohinski/gonja v1.5.3/go.mod h1:RmjwxNiXAEqcq1HeK5SSMmqFJvKOfTfXhkJv6YBtPa4=
173 | github.com/ollama/ollama v0.5.12 h1:qM+k/ozyHLJzEQoAEPrUQ0qXqsgDEEdpIVwuwScrd2U=
174 | github.com/ollama/ollama v0.5.12/go.mod h1:ibdmDvb/TjKY1OArBWIazL3pd1DHTk8eG2MMjEkWhiI=
175 | github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
176 | github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
177 | github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
178 | github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
179 | github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
180 | github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s=
181 | github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw=
182 | github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
183 | github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
184 | github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
185 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
186 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
187 | github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
188 | github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
189 | github.com/rollbar/rollbar-go v1.0.2/go.mod h1:AcFs5f0I+c71bpHlXNNDbOWJiKwjFDtISeXco0L5PKQ=
190 | github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
191 | github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
192 | github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
193 | github.com/sagikazarmark/locafero v0.7.0 h1:5MqpDsTGNDhY8sGp0Aowyf0qKsPrhewaLSsFaodPcyo=
194 | github.com/sagikazarmark/locafero v0.7.0/go.mod h1:2za3Cg5rMaTMoG/2Ulr9AwtFaIppKXTRYnozin4aB5k=
195 | github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
196 | github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
197 | github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
198 | github.com/slongfield/pyfmt v0.0.0-20220222012616-ea85ff4c361f h1:Z2cODYsUxQPofhpYRMQVwWz4yUVpHF+vPi+eUdruUYI=
199 | github.com/slongfield/pyfmt v0.0.0-20220222012616-ea85ff4c361f/go.mod h1:JqzWyvTuI2X4+9wOHmKSQCYxybB/8j6Ko43qVmXDuZg=
200 | github.com/smarty/assertions v1.15.0 h1:cR//PqUBUiQRakZWqBiFFQ9wb8emQGDb0HeGdqGByCY=
201 | github.com/smarty/assertions v1.15.0/go.mod h1:yABtdzeQs6l1brC900WlRNwj6ZR55d7B+E8C6HtKdec=
202 | github.com/smartystreets/goconvey v1.8.1 h1:qGjIddxOk4grTu9JPOU31tVfq3cNdBlNa5sSznIX1xY=
203 | github.com/smartystreets/goconvey v1.8.1/go.mod h1:+/u4qLyY6x1jReYOp7GOM2FSt8aP9CzCZL03bI28W60=
204 | github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
205 | github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
206 | github.com/spf13/afero v1.12.0 h1:UcOPyRBYczmFn6yvphxkn9ZEOY65cpwGKb5mL36mrqs=
207 | github.com/spf13/afero v1.12.0/go.mod h1:ZTlWwG4/ahT8W7T0WQ5uYmjI9duaLQGy3Q2OAl4sk/4=
208 | github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
209 | github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
210 | github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
211 | github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
212 | github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4=
213 | github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=
214 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
215 | github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
216 | github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
217 | github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
218 | github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
219 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
220 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
221 | github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
222 | github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
223 | github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
224 | github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
225 | github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
226 | github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
227 | github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
228 | github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
229 | github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
230 | github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
231 | github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
232 | github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
233 | github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
234 | github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
235 | github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
236 | github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
237 | github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
238 | github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
239 | github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
240 | github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
241 | github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
242 | github.com/x-cray/logrus-prefixed-formatter v0.5.2 h1:00txxvfBM9muc0jiLIEAkAcIMJzfthRT6usrui8uGmg=
243 | github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE=
244 | github.com/yargevad/filepathx v1.0.0 h1:SYcT+N3tYGi+NvazubCNlvgIPbzAk7i7y2dwg3I5FYc=
245 | github.com/yargevad/filepathx v1.0.0/go.mod h1:BprfX/gpYNJHJfc35GjRRpVcwWXS89gGulUIU5tK3tA=
246 | github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
247 | github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
248 | go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
249 | go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
250 | go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw=
251 | go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8=
252 | go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc=
253 | go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8=
254 | go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4=
255 | go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ=
256 | go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
257 | go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
258 | go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
259 | go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
260 | golang.org/x/arch v0.11.0 h1:KXV8WWKCXm6tRpLirl2szsO5j/oOODwZf4hATmGVNs4=
261 | golang.org/x/arch v0.11.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
262 | golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
263 | golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
264 | golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
265 | golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
266 | golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
267 | golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
268 | golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
269 | golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
270 | golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
271 | golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
272 | golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
273 | golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
274 | golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
275 | golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
276 | golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
277 | golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
278 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
279 | golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
280 | golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
281 | golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
282 | golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
283 | golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
284 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
285 | golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
286 | golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
287 | google.golang.org/genai v1.11.0 h1:Jyc6fsjJlpxAVNSqLW10alnWr7fcm117aL5BJrrg2Tc=
288 | google.golang.org/genai v1.11.0/go.mod h1:TyfOKRz/QyCaj6f/ZDt505x+YreXnY40l2I6k8TvgqY=
289 | google.golang.org/genproto/googleapis/rpc v0.0.0-20241223144023-3abc09e42ca8 h1:TqExAhdPaB60Ux47Cn0oLV07rGnxZzIsaRhQaqS666A=
290 | google.golang.org/genproto/googleapis/rpc v0.0.0-20241223144023-3abc09e42ca8/go.mod h1:lcTa1sDdWEIHMWlITnIczmw5w60CF9ffkb8Z+DVmmjA=
291 | google.golang.org/grpc v1.67.3 h1:OgPcDAFKHnH8X3O4WcO4XUc8GRDeKsKReqbQtiCj7N8=
292 | google.golang.org/grpc v1.67.3/go.mod h1:YGaHCc6Oap+FzBJTZLBzkGSYt/cvGPFTPxkn7QfSU8s=
293 | google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
294 | google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
295 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
296 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
297 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
298 | gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
299 | gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
300 | gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
301 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
302 | gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
303 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
304 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
305 | nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
306 | 


--------------------------------------------------------------------------------