Merge branch 'main' into 3318-RavenDB-state-store-new

Author: nmalocicvega

common/component/azure/servicebus/message.go

@@ -122,7 +122,7 @@ func addMetadataToMessage(asbMsg *azservicebus.Message, metadata map[string]stri
 
 		switch k {
 		// Common keys
-		case mdutils.TTLMetadataKey:
+		case mdutils.TTLMetadataKey, mdutils.TTLInSecondsMetadataKey:
 			// Ignore v here and use TryGetTTL for the validation it performs
 			ttl, ok, _ := mdutils.TryGetTTL(metadata)
 			if ok {

conversation/deepseek/deepseek.go

@@ -59,6 +59,10 @@ func (d *Deepseek) Init(ctx context.Context, meta conversation.Metadata) error {
 		model = md.Model
 	}
 
+	if md.Endpoint == "" {
+		md.Endpoint = defaultEndpoint
+	}
+
 	options := []openai.Option{
 		openai.WithModel(model),
 		openai.WithToken(md.Key),

conversation/echo/echo.go

@@ -18,6 +18,8 @@ import (
 	"context"
 	"fmt"
 	"reflect"
+	"strconv"
+	"strings"
 
 	"github.com/tmc/langchaingo/llms"
 
@@ -61,67 +63,104 @@ func (e *Echo) GetComponentMetadata() (metadataInfo metadata.MetadataMap) {
 
 // Converse returns one output per input message.
 func (e *Echo) Converse(ctx context.Context, r *conversation.Request) (res *conversation.Response, err error) {
-	if r.Message == nil {
+	if r == nil || r.Message == nil {
 		return &conversation.Response{
 			ConversationContext: r.ConversationContext,
 			Outputs:             []conversation.Result{},
 		}, nil
 	}
 
-	outputs := make([]conversation.Result, 0, len(*r.Message))
+	// if we get tools, respond with tool calls for each tool
+	var toolCalls []llms.ToolCall
+	if r.Tools != nil {
+		// create tool calls for each tool
+		toolCalls = make([]llms.ToolCall, 0, len(*r.Tools))
+		for id, tool := range *r.Tools {
+			// extract argument names from parameters.properties
+			if tool.Function == nil {
+				continue // skip if no function
+			}
+			// try to get parameters/arg-names from tool function if any
+			var parameters map[string]any
+			var argNames []string
+			if tool.Function.Parameters != nil {
+				// ensure parameters are a map
+				ok := false
+				parameters, ok = tool.Function.Parameters.(map[string]any)
+				if !ok {
+					return nil, fmt.Errorf("tool function parameters must be a map[string]any, got %T", tool.Function.Parameters)
+				}
+			}
+			// try get arg names from properties
+			if properties, ok := parameters["properties"]; ok {
+				_, ok = properties.(map[string]any)
+				if !ok {
+					return nil, fmt.Errorf("tool function properties must be a map[string]any, got %T", properties)
+				}
+				if propMap, ok := properties.(map[string]any); ok && len(propMap) != 0 {
+					argNames = make([]string, 0, len(propMap))
+					for argName := range propMap {
+						argNames = append(argNames, argName)
+					}
+				}
+			}
 
-	for _, message := range *r.Message {
-		var content string
-		var toolCalls []llms.ToolCall
+			toolCalls = append(toolCalls, llms.ToolCall{
+				ID:   strconv.Itoa(id),
+				Type: tool.Type,
+				FunctionCall: &llms.FunctionCall{
+					Name:      tool.Function.Name,
+					Arguments: strings.Join(argNames, ","),
+				},
+			})
+		}
+	}
 
-		for i, part := range message.Parts {
+	// iterate over each message in the request to echo back the content in the response. We respond with the acummulated content of the message parts and tool responses
+	contentFromMessaged := make([]string, 0, len(*r.Message))
+	for _, message := range *r.Message {
+		for _, part := range message.Parts {
 			switch p := part.(type) {
 			case llms.TextContent:
-				// end with space if not the first part
-				if i > 0 && content != "" {
-					content += " "
-				}
-				content += p.Text
+				// append to slice that we'll join later with new line separators
+				contentFromMessaged = append(contentFromMessaged, p.Text)
 			case llms.ToolCall:
+				// in case we added explicit tool calls on the request like on multi-turn conversations. We still append tool calls for each tool defined in the request.
 				toolCalls = append(toolCalls, p)
 			case llms.ToolCallResponse:
-				content = p.Content
-				toolCalls = append(toolCalls, llms.ToolCall{
-					ID:   p.ToolCallID,
-					Type: "function",
-					FunctionCall: &llms.FunctionCall{
-						Name:      p.Name,
-						Arguments: p.Content,
-					},
-				})
+				// show tool responses on the request like on multi-turn conversations
+				contentFromMessaged = append(contentFromMessaged, fmt.Sprintf("Tool Response for tool ID '%s' with name '%s': %s", p.ToolCallID, p.Name, p.Content))
 			default:
 				return nil, fmt.Errorf("found invalid content type as input for %v", p)
 			}
 		}
+	}
 
-		choice := conversation.Choice{
-			FinishReason: "stop",
-			Index:        0,
-			Message: conversation.Message{
-				Content: content,
-			},
-		}
-
-		if len(toolCalls) > 0 {
-			choice.Message.ToolCallRequest = &toolCalls
-		}
+	stopReason := "stop"
+	if len(toolCalls) > 0 {
+		stopReason = "tool_calls"
+		// follows openai spec for tool_calls finish reason https://platform.openai.com/docs/api-reference/chat/object
+	}
+	choice := conversation.Choice{
+		FinishReason: stopReason,
+		Index:        0,
+		Message: conversation.Message{
+			Content: strings.Join(contentFromMessaged, "\n"),
+		},
+	}
 
-		output := conversation.Result{
-			StopReason: "stop",
-			Choices:    []conversation.Choice{choice},
-		}
+	if len(toolCalls) > 0 {
+		choice.Message.ToolCallRequest = &toolCalls
+	}
 
-		outputs = append(outputs, output)
+	output := conversation.Result{
+		StopReason: stopReason,
+		Choices:    []conversation.Choice{choice},
 	}
 
 	res = &conversation.Response{
 		ConversationContext: r.ConversationContext,
-		Outputs:             outputs,
+		Outputs:             []conversation.Result{output},
 	}
 
 	return res, nil

conversation/echo/echo_test.go

@@ -97,19 +97,7 @@ func TestConverse(t *testing.T) {
 								FinishReason: "stop",
 								Index:        0,
 								Message: conversation.Message{
-									Content: "first message second message",
-								},
-							},
-						},
-					},
-					{
-						StopReason: "stop",
-						Choices: []conversation.Choice{
-							{
-								FinishReason: "stop",
-								Index:        0,
-								Message: conversation.Message{
-									Content: "third message",
+									Content: "first message\nsecond message\nthird message",
 								},
 							},
 						},
@@ -127,7 +115,7 @@ func TestConverse(t *testing.T) {
 				Message: &tt.inputs,
 			})
 			require.NoError(t, err)
-			assert.Len(t, r.Outputs, len(tt.expected.Outputs))
+			assert.Len(t, r.Outputs, 1)
 			assert.Equal(t, tt.expected.Outputs, r.Outputs)
 		})
 	}
@@ -137,20 +125,32 @@ func TestConverseAlpha2(t *testing.T) {
 	tests := []struct {
 		name     string
 		messages []llms.MessageContent
+		tools    []llms.Tool
 		expected *conversation.Response
 	}{
 		{
 			name: "tool call request",
 			messages: []llms.MessageContent{
 				{
-					Role: llms.ChatMessageTypeAI,
+					Role: llms.ChatMessageTypeHuman,
 					Parts: []llms.ContentPart{
-						llms.ToolCall{
-							ID:   "myid",
-							Type: "function",
-							FunctionCall: &llms.FunctionCall{
-								Name:      "myfunc",
-								Arguments: `{"name": "Dapr"}`,
+						llms.TextContent{Text: "hello echo"},
+					},
+				},
+			},
+			tools: []llms.Tool{
+				{
+					Type: "function",
+					Function: &llms.FunctionDefinition{
+						Name:        "myfunc",
+						Description: "A function that does something",
+						Parameters: map[string]any{
+							"type": "object",
+							"properties": map[string]any{
+								"name": map[string]any{
+									"type":        "string",
+									"description": "The name to process",
+								},
 							},
 						},
 					},
@@ -159,19 +159,20 @@ func TestConverseAlpha2(t *testing.T) {
 			expected: &conversation.Response{
 				Outputs: []conversation.Result{
 					{
-						StopReason: "stop",
+						StopReason: "tool_calls",
 						Choices: []conversation.Choice{
 							{
-								FinishReason: "stop",
+								FinishReason: "tool_calls",
 								Index:        0,
 								Message: conversation.Message{
+									Content: "hello echo",
 									ToolCallRequest: &[]llms.ToolCall{
 										{
-											ID:   "myid",
+											ID:   "0", // ID is auto-generated by the echo component
 											Type: "function",
 											FunctionCall: &llms.FunctionCall{
 												Name:      "myfunc",
-												Arguments: `{"name": "Dapr"}`,
+												Arguments: "name",
 											},
 										},
 									},
@@ -183,8 +184,15 @@ func TestConverseAlpha2(t *testing.T) {
 			},
 		},
 		{
-			name: "tool call response",
+			name: "text message with tool call response",
+			// echo responds with the text message and tool call response appended to the message content
 			messages: []llms.MessageContent{
+				{
+					Role: llms.ChatMessageTypeHuman,
+					Parts: []llms.ContentPart{
+						llms.TextContent{Text: "hello echo"},
+					},
+				},
 				{
 					Role: llms.ChatMessageTypeTool,
 					Parts: []llms.ContentPart{
@@ -205,62 +213,7 @@ func TestConverseAlpha2(t *testing.T) {
 								FinishReason: "stop",
 								Index:        0,
 								Message: conversation.Message{
-									Content: "Dapr",
-									ToolCallRequest: &[]llms.ToolCall{
-										{
-											ID:   "myid",
-											Type: "function",
-											FunctionCall: &llms.FunctionCall{
-												Name:      "myfunc",
-												Arguments: "Dapr",
-											},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "mixed content with text and tool call",
-			messages: []llms.MessageContent{
-				{
-					Role: llms.ChatMessageTypeAI,
-					Parts: []llms.ContentPart{
-						llms.TextContent{Text: "text msg"},
-						llms.ToolCall{
-							ID:   "myid",
-							Type: "function",
-							FunctionCall: &llms.FunctionCall{
-								Name:      "myfunc",
-								Arguments: `{"name": "Dapr"}`,
-							},
-						},
-					},
-				},
-			},
-			expected: &conversation.Response{
-				Outputs: []conversation.Result{
-					{
-						StopReason: "stop",
-						Choices: []conversation.Choice{
-							{
-								FinishReason: "stop",
-								Index:        0,
-								Message: conversation.Message{
-									Content: "text msg",
-									ToolCallRequest: &[]llms.ToolCall{
-										{
-											ID:   "myid",
-											Type: "function",
-											FunctionCall: &llms.FunctionCall{
-												Name:      "myfunc",
-												Arguments: `{"name": "Dapr"}`,
-											},
-										},
-									},
+									Content: "hello echo\nTool Response for tool ID 'myid' with name 'myfunc': Dapr",
 								},
 							},
 						},
@@ -275,9 +228,14 @@ func TestConverseAlpha2(t *testing.T) {
 			e := NewEcho(logger.NewLogger("echo test"))
 			e.Init(t.Context(), conversation.Metadata{})
 
-			r, err := e.Converse(t.Context(), &conversation.Request{
+			request := &conversation.Request{
 				Message: &tt.messages,
-			})
+			}
+			if len(tt.tools) > 0 {
+				request.Tools = &tt.tools
+			}
+
+			r, err := e.Converse(t.Context(), request)
 			require.NoError(t, err)
 
 			assert.Len(t, r.Outputs, 1)
@@ -295,7 +253,6 @@ func TestConverseAlpha2(t *testing.T) {
 
 				for j, toolCall := range *choice.Message.ToolCallRequest {
 					expectedToolCall := (*expectedChoice.Message.ToolCallRequest)[j]
-					assert.Equal(t, expectedToolCall.ID, toolCall.ID)
 					assert.Equal(t, expectedToolCall.Type, toolCall.Type)
 
 					if expectedToolCall.FunctionCall != nil {