Merge branch 'main-pull-requests' into main-vxcontrol

Author: asdek

agents/executor.go

@@ -134,7 +134,7 @@ func (e *Executor) doAction(
 		}), nil
 	}
 
-	observation, err := tool.Call(ctx, action.ToolInput)
+	observation, err := tool.Call(ctx, strings.TrimSuffix(action.ToolInput, "\nObservation:"))
 	if err != nil {
 		return nil, err
 	}

agents/executor_test.go

@@ -24,6 +24,7 @@ type testAgent struct {
 	err        error
 	inputKeys  []string
 	outputKeys []string
+	tools      []tools.Tool
 
 	recordedIntermediateSteps []schema.AgentStep
 	recordedInputs            map[string]string
@@ -51,7 +52,7 @@ func (a testAgent) GetOutputKeys() []string {
 }
 
 func (a *testAgent) GetTools() []tools.Tool {
-	return nil
+	return a.tools
 }
 
 func TestExecutorWithErrorHandler(t *testing.T) {
@@ -173,3 +174,59 @@ func TestExecutorWithOpenAIFunctionAgent(t *testing.T) {
 	require.True(t, strings.Contains(result, "2012") || strings.Contains(result, "March"),
 		"correct answer 2012 or March not in response")
 }
+
+// mockTool implements the tools.Tool interface for testing
+type mockTool struct {
+	name             string
+	description      string
+	receivedInputPtr *string
+}
+
+func (m *mockTool) Name() string {
+	return m.name
+}
+
+func (m *mockTool) Description() string {
+	return m.description
+}
+
+func (m *mockTool) Call(_ context.Context, input string) (string, error) {
+	*m.receivedInputPtr = input
+	return "mock result", nil
+}
+
+func TestExecutorTrimsObservationSuffix(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	// Create a mock tool that records what input it receives
+	var receivedInput string
+	mockToolInst := &mockTool{
+		name:             "mock_tool",
+		description:      "A mock tool for testing",
+		receivedInputPtr: &receivedInput,
+	}
+
+	// Create a test agent that returns an action with trailing "\nObservation:"
+	testAgent := &testAgent{
+		actions: []schema.AgentAction{
+			{
+				Tool:      "mock_tool",
+				ToolInput: "test input\nObservation:",
+				Log:       "Action: mock_tool\nAction Input: test input\nObservation:",
+			},
+		},
+		inputKeys:  []string{"input"},
+		outputKeys: []string{"output"},
+		tools:      []tools.Tool{mockToolInst},
+	}
+
+	executor := agents.NewExecutor(testAgent, agents.WithMaxIterations(1))
+
+	_, err := chains.Call(ctx, executor, map[string]any{"input": "test question"})
+	// We expect ErrNotFinished since our test agent doesn't provide a finish action
+	require.ErrorIs(t, err, agents.ErrNotFinished)
+
+	// Verify that the tool received the input with "\nObservation:" trimmed off
+	require.Equal(t, "test input", receivedInput, "Tool should receive input with \\nObservation: suffix trimmed")
+}

agents/markl_test.go

@@ -37,6 +37,16 @@ func TestMRKLOutputParser(t *testing.T) {
 			expectedFinish: nil,
 			expectedErr:    nil,
 		},
+		{
+			input: "Action: calculator\nAction Input: 5 + 3\nObservation:",
+			expectedActions: []schema.AgentAction{{
+				Tool:      "calculator",
+				ToolInput: "5 + 3\nObservation:",
+				Log:       "Action: calculator\nAction Input: 5 + 3\nObservation:",
+			}},
+			expectedFinish: nil,
+			expectedErr:    nil,
+		},
 	}
 
 	a := OneShotZeroAgent{}

docs/package.json

@@ -62,5 +62,10 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "pnpm": {
+    "overrides": {
+      "webpack-dev-server": ">=5.2.1"
+    }
   }
 }

llms/bedrock/bedrockllm_test.go

@@ -1,10 +1,11 @@
 package bedrock_test
 
 import (
+	"context"
 	"net/http"
+	"os"
 	"testing"
 
-	"github.com/vxcontrol/langchaingo/httputil"
 	"github.com/vxcontrol/langchaingo/internal/httprr"
 	"github.com/vxcontrol/langchaingo/llms"
 	"github.com/vxcontrol/langchaingo/llms/bedrock"
@@ -13,13 +14,25 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
 )
 
-func setupTest(t *testing.T) (*bedrockruntime.Client, error) {
-	t.Helper()
+func setUpTestWithTransport(rr *httprr.RecordReplay) (*bedrockruntime.Client, error) {
+	// Configure request scrubbing to remove dynamic AWS headers
+	rr.ScrubReq(func(req *http.Request) error {
+		req.Header.Del("Amz-Sdk-Invocation-Id")
+		req.Header.Del("Amz-Sdk-Request")
+		req.Header.Del("X-Amz-Date")
+		return nil
+	})
 
-	cfg, err := config.LoadDefaultConfig(t.Context())
+	httpClient := &http.Client{
+		Transport: rr,
+	}
+
+	cfg, err := config.LoadDefaultConfig(context.Background(),
+		config.WithHTTPClient(httpClient))
 	if err != nil {
 		return nil, err
 	}
+
 	client := bedrockruntime.NewFromConfig(cfg)
 	return client, nil
 }
@@ -37,12 +50,8 @@ func TestAmazonOutput(t *testing.T) {
 		t.Parallel()
 	}
 
-	// Replace httputil.DefaultClient with httprr client
-	oldClient := httputil.DefaultClient
-	httputil.DefaultClient = rr.Client()
-	defer func() { httputil.DefaultClient = oldClient }()
-
-	client, err := setupTest(t)
+	// Configure AWS client to use httprr transport
+	client, err := setUpTestWithTransport(rr)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -68,8 +77,6 @@ func TestAmazonOutput(t *testing.T) {
 
 	// All the test models.
 	models := []string{
-		bedrock.ModelAi21J2MidV1,
-		bedrock.ModelAi21J2UltraV1,
 		bedrock.ModelAmazonTitanTextLiteV1,
 		bedrock.ModelAmazonTitanTextExpressV1,
 		bedrock.ModelAnthropicClaudeV3Sonnet,
@@ -79,10 +86,11 @@ func TestAmazonOutput(t *testing.T) {
 		bedrock.ModelAnthropicClaudeInstantV1,
 		bedrock.ModelCohereCommandTextV14,
 		bedrock.ModelCohereCommandLightTextV14,
-		bedrock.ModelMetaLlama213bChatV1,
-		bedrock.ModelMetaLlama270bChatV1,
 		bedrock.ModelMetaLlama38bInstructV1,
 		bedrock.ModelMetaLlama370bInstructV1,
+		bedrock.ModelAmazonNovaMicroV1,
+		bedrock.ModelAmazonNovaLiteV1,
+		bedrock.ModelAmazonNovaProV1,
 	}
 
 	for _, model := range models {
@@ -97,3 +105,125 @@ func TestAmazonOutput(t *testing.T) {
 		}
 	}
 }
+
+func TestAmazonNova(t *testing.T) {
+	httprr.SkipIfNoCredentialsAndRecordingMissing(t, "AWS_ACCESS_KEY_ID")
+
+	rr := httprr.OpenForTest(t, http.DefaultTransport)
+	defer rr.Close()
+
+	// Only run tests in parallel when not recording (to avoid rate limits)
+	if !rr.Recording() {
+		t.Parallel()
+	}
+
+	// Configure AWS client to use httprr transport
+	client, err := setUpTestWithTransport(rr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llm, err := bedrock.New(bedrock.WithClient(client))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := []llms.MessageContent{
+		{
+			Role: llms.ChatMessageTypeSystem,
+			Parts: []llms.ContentPart{
+				llms.TextPart("You know all about AI."),
+			},
+		},
+		{
+			Role: llms.ChatMessageTypeHuman,
+			Parts: []llms.ContentPart{
+				llms.TextPart("Explain AI in 10 words or less."),
+			},
+		},
+	}
+
+	// All the test models.
+	models := []string{
+		bedrock.ModelAmazonNovaMicroV1,
+		bedrock.ModelAmazonNovaLiteV1,
+		bedrock.ModelAmazonNovaProV1,
+	}
+
+	ctx := context.Background()
+
+	for _, model := range models {
+		t.Logf("Model output for %s:-", model)
+
+		resp, err := llm.GenerateContent(ctx, msgs, llms.WithModel(model), llms.WithMaxTokens(4096))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for i, choice := range resp.Choices {
+			t.Logf("Choice %d: %s", i, choice.Content)
+		}
+	}
+}
+
+func TestAnthropicNovaImage(t *testing.T) {
+	httprr.SkipIfNoCredentialsAndRecordingMissing(t, "AWS_ACCESS_KEY_ID")
+
+	rr := httprr.OpenForTest(t, http.DefaultTransport)
+	defer rr.Close()
+
+	// Only run tests in parallel when not recording (to avoid rate limits)
+	if !rr.Recording() {
+		t.Parallel()
+	}
+
+	// Configure AWS client to use httprr transport
+	client, err := setUpTestWithTransport(rr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llm, err := bedrock.New(bedrock.WithClient(client))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	image, err := os.ReadFile("testdata/wikipage.jpg")
+	mimeType := "image/jpeg"
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := []llms.MessageContent{
+		{
+			Role: llms.ChatMessageTypeSystem,
+			Parts: []llms.ContentPart{
+				llms.TextPart("You know all about AI."),
+			},
+		},
+		{
+			Role: llms.ChatMessageTypeHuman,
+			Parts: []llms.ContentPart{
+				llms.TextPart("Explain AI according to the image. Provide quotes from the image."),
+				llms.BinaryPart(mimeType, image),
+			},
+		},
+	}
+
+	// All the test models.
+	models := []string{
+		bedrock.ModelAmazonNovaLiteV1,
+		bedrock.ModelAmazonNovaProV1,
+	}
+
+	ctx := context.Background()
+
+	for _, model := range models {
+		t.Logf("Model output for %s:-", model)
+
+		resp, err := llm.GenerateContent(ctx, msgs, llms.WithModel(model), llms.WithMaxTokens(4096))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for i, choice := range resp.Choices {
+			t.Logf("Choice %d: %s", i, choice.Content)
+		}
+	}
+}

llms/bedrock/internal/bedrockclient/bedrockclient.go

@@ -30,6 +30,14 @@ type Message struct {
 }
 
 func getProvider(modelID string) string {
+	// Check for Nova models (including inference profiles like us.amazon.nova-*)
+	if strings.Contains(modelID, ".nova-") || strings.Contains(modelID, "amazon.nova-") {
+		return "nova"
+	}
+	
+	parts := strings.Split(modelID, ".")
+	
+	// For backward compatibility with the original provider detection
 	switch {
 	case strings.Contains(modelID, "ai21"):
 		return "ai21"
@@ -41,9 +49,14 @@ func getProvider(modelID string) string {
 		return "cohere"
 	case strings.Contains(modelID, "meta"):
 		return "meta"
-	default:
-		return ""
 	}
+
+	// Default to using the first part of the model ID
+	if len(parts) > 0 {
+		return parts[0]
+	}
+	
+	return ""
 }
 
 // NewClient creates a new Bedrock client.
@@ -66,6 +79,8 @@ func (c *Client) CreateCompletion(ctx context.Context,
 		return createAi21Completion(ctx, c.client, modelID, messages, options)
 	case "amazon":
 		return createAmazonCompletion(ctx, c.client, modelID, messages, options)
+	case "nova":
+		return createNovaCompletion(ctx, c.client, modelID, messages, options)
 	case "anthropic":
 		return createAnthropicCompletion(ctx, c.client, modelID, messages, options)
 	case "cohere":

llms/bedrock/internal/bedrockclient/bedrockclient_test.go

@@ -46,7 +46,7 @@ func TestGetProvider(t *testing.T) {
 		{
 			name:     "unknown provider",
 			modelID:  "unknown.model",
-			expected: "",
+			expected: "unknown",
 		},
 	}