fix: interface signature for Explain API (#75)

Author: ShawkyZ

llm/api_client.go

@@ -17,7 +17,7 @@ const (
 	defaultEndpointURL            = "http://localhost:10000/explain"
 )
 
-func (d *DeepcodeLLMBinding) runExplain(ctx context.Context, options ExplainOptions) (explainResponse, error) {
+func (d *DeepCodeLLMBindingImpl) runExplain(ctx context.Context, options ExplainOptions) (explainResponse, error) {
 	span := d.instrumentor.StartSpan(ctx, "code.RunExplain")
 	defer span.Finish()
 
@@ -46,7 +46,7 @@ func (d *DeepcodeLLMBinding) runExplain(ctx context.Context, options ExplainOpti
 			return explainResponse{}, err
 		}
 	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), bytes.NewBuffer(requestBody))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, u.String(), bytes.NewBuffer(requestBody))
 	if err != nil {
 		logger.Err(err).Str("requestBody", string(requestBody)).Msg("error creating request")
 		return explainResponse{}, err
@@ -84,7 +84,7 @@ func (d *DeepcodeLLMBinding) runExplain(ctx context.Context, options ExplainOpti
 	return response, nil
 }
 
-func (d *DeepcodeLLMBinding) explainRequestBody(options *ExplainOptions) ([]byte, error) {
+func (d *DeepCodeLLMBindingImpl) explainRequestBody(options *ExplainOptions) ([]byte, error) {
 	logger := d.logger.With().Str("method", "code.explainRequestBody").Logger()
 
 	var request explainRequest
@@ -108,7 +108,7 @@ func (d *DeepcodeLLMBinding) explainRequestBody(options *ExplainOptions) ([]byte
 	return requestBody, err
 }
 
-func (d *DeepcodeLLMBinding) addDefaultHeaders(req *http.Request, requestId string) {
+func (d *DeepCodeLLMBindingImpl) addDefaultHeaders(req *http.Request, requestId string) {
 	req.Header.Set("snyk-request-id", requestId)
 	req.Header.Set("Cache-Control", "private, max-age=0, no-cache")
 	req.Header.Set("Content-Type", "application/json")

llm/api_client_test.go

@@ -118,7 +118,7 @@ func TestDeepcodeLLMBinding_runExplain(t *testing.T) {
 }
 
 func TestDeepcodeLLMBinding_explainRequestBody(t *testing.T) {
-	d := &DeepcodeLLMBinding{
+	d := &DeepCodeLLMBindingImpl{
 		logger: testLogger(t),
 	}
 
@@ -172,7 +172,7 @@ func testLogger(t *testing.T) *zerolog.Logger {
 
 // Test with existing headers
 func TestAddDefaultHeadersWithExistingHeaders(t *testing.T) {
-	d := &DeepcodeLLMBinding{} // Initialize your struct if needed
+	d := &DeepCodeLLMBindingImpl{} // Initialize your struct if needed
 	req := &http.Request{Header: http.Header{"Existing-Header": {"existing-value"}}}
 	requestId := "test-request-id"
 

llm/binding.go

@@ -6,6 +6,7 @@ import (
 	"net/url"
 
 	"github.com/rs/zerolog"
+
 	"github.com/snyk/code-client-go/http"
 
 	"github.com/snyk/code-client-go/observability"
@@ -22,41 +23,45 @@ type AIRequest struct {
 	Input string `json:"inputs"`
 }
 
+var _ DeepCodeLLMBinding = (*DeepCodeLLMBindingImpl)(nil)
+var _ SnykLLMBindings = (*DeepCodeLLMBindingImpl)(nil)
+
 type SnykLLMBindings interface {
 	// PublishIssues sends issues to an LLM for further processing.
 	// the map in the slice of issues map is a json representation of json key : value
 	// In case of errors, they are returned
-	PublishIssues(issues []map[string]string) error
+	PublishIssues(ctx context.Context, issues []map[string]string) error
 
 	// Explain forwards an input and desired output format to an LLM to
 	// receive an explanation. The implementation should alter the LLM
 	// prompt to honor the output format, but is not required to enforce
 	// the format. The results should be streamed into the given channel
 	//
 	// Parameters:
+	// ctx - request context
 	// input - the thing to be explained as a string
 	// format - the requested outputFormat
 	// output - a channel that can be used to stream the results
-	Explain(input AIRequest, format OutputFormat, output chan<- string) error
+	Explain(ctx context.Context, input AIRequest, format OutputFormat, output chan<- string) error
 }
 
 type DeepCodeLLMBinding interface {
 	SnykLLMBindings
-	ExplainWithOptions(options ExplainOptions) (string, error)
+	ExplainWithOptions(ctx context.Context, options ExplainOptions) (string, error)
 }
 
-// DeepcodeLLMBinding is an LLM binding for the Snyk Code LLM.
+// DeepCodeLLMBindingImpl is an LLM binding for the Snyk Code LLM.
 // Currently, it only supports explain.
-type DeepcodeLLMBinding struct {
+type DeepCodeLLMBindingImpl struct {
 	httpClientFunc func() http.HTTPClient
 	logger         *zerolog.Logger
 	outputFormat   OutputFormat
 	instrumentor   observability.Instrumentor
 	endpoint       *url.URL
 }
 
-func (d *DeepcodeLLMBinding) ExplainWithOptions(options ExplainOptions) (string, error) {
-	s := d.instrumentor.StartSpan(context.Background(), "code.ExplainWithOptions")
+func (d *DeepCodeLLMBindingImpl) ExplainWithOptions(ctx context.Context, options ExplainOptions) (string, error) {
+	s := d.instrumentor.StartSpan(ctx, "code.ExplainWithOptions")
 	defer d.instrumentor.Finish(s)
 	response, err := d.runExplain(s.Context(), options)
 	if err != nil {
@@ -66,33 +71,33 @@ func (d *DeepcodeLLMBinding) ExplainWithOptions(options ExplainOptions) (string,
 	return response.Explanation, nil
 }
 
-func (d *DeepcodeLLMBinding) PublishIssues(issues []map[string]string) error {
+func (d *DeepCodeLLMBindingImpl) PublishIssues(_ context.Context, _ []map[string]string) error {
 	panic("implement me")
 }
 
-func (d *DeepcodeLLMBinding) Explain(input string, format OutputFormat, output chan<- string) error {
+func (d *DeepCodeLLMBindingImpl) Explain(ctx context.Context, input AIRequest, _ OutputFormat, output chan<- string) error {
 	var options ExplainOptions
-	err := json.Unmarshal([]byte(input), &options)
+	err := json.Unmarshal([]byte(input.Input), &options)
 	if err != nil {
 		return err
 	}
-	response, err := d.ExplainWithOptions(options)
+	response, err := d.ExplainWithOptions(ctx, options)
 	if err != nil {
 		return err
 	}
 	output <- response
 	return nil
 }
 
-func NewDeepcodeLLMBinding(opts ...Option) *DeepcodeLLMBinding {
+func NewDeepcodeLLMBinding(opts ...Option) *DeepCodeLLMBindingImpl {
 	endpoint, err := url.Parse(defaultEndpointURL)
 	if err != nil {
 		// time to panic, as our default should never be invalid
 		panic(err)
 	}
 
 	nopLogger := zerolog.Nop()
-	binding := &DeepcodeLLMBinding{
+	binding := &DeepCodeLLMBindingImpl{
 		logger: &nopLogger,
 		httpClientFunc: func() http.HTTPClient {
 			return http.NewHTTPClient(

llm/binding_smoke_test.go

@@ -1,11 +1,14 @@
 package llm
 
 import (
+	"context"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/rs/zerolog"
-	"github.com/snyk/code-client-go/http"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/snyk/code-client-go/http"
 )
 
 func TestDeepcodeLLMBinding_Explain_Smoke(t *testing.T) {
@@ -17,6 +20,6 @@ func TestDeepcodeLLMBinding_Explain_Smoke(t *testing.T) {
 		WithLogger(&logger),
 	)
 	outputChain := make(chan string)
-	err := binding.Explain("{}", HTML, outputChain)
+	err := binding.Explain(context.Background(), AIRequest{Id: uuid.New().String(), Input: "{}"}, HTML, outputChain)
 	assert.NoError(t, err)
 }

llm/binding_test.go

@@ -1,6 +1,7 @@
 package llm
 
 import (
+	"context"
 	"encoding/json"
 	"io"
 	http2 "net/http"
@@ -10,16 +11,17 @@ import (
 
 	"github.com/golang/mock/gomock"
 	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/assert"
+
 	"github.com/snyk/code-client-go/http"
 	"github.com/snyk/code-client-go/http/mocks"
-	"github.com/stretchr/testify/assert"
 
 	"github.com/snyk/code-client-go/observability"
 )
 
 func TestDeepcodeLLMBinding_PublishIssues(t *testing.T) {
 	binding := NewDeepcodeLLMBinding()
-	assert.PanicsWithValue(t, "implement me", func() { _ = binding.PublishIssues([]map[string]string{}) })
+	assert.PanicsWithValue(t, "implement me", func() { _ = binding.PublishIssues(context.Background(), []map[string]string{}) })
 }
 
 func TestExplainWithOptions(t *testing.T) {
@@ -39,7 +41,7 @@ func TestExplainWithOptions(t *testing.T) {
 			Body:       io.NopCloser(strings.NewReader(string(expectedResponseBody))),
 		}
 		mockHTTPClient.EXPECT().Do(gomock.Any()).Return(&mockResponse, nil)
-		explanation, err := d.ExplainWithOptions(ExplainOptions{})
+		explanation, err := d.ExplainWithOptions(context.Background(), ExplainOptions{})
 		assert.NoError(t, err)
 		assert.Equal(t, explainResponseJSON.Explanation, explanation)
 	})
@@ -49,7 +51,7 @@ func TestExplainWithOptions(t *testing.T) {
 	})
 }
 
-func getHTTPMockedBinding(t *testing.T, endpoint *url.URL) (*DeepcodeLLMBinding, *mocks.MockHTTPClient) {
+func getHTTPMockedBinding(t *testing.T, endpoint *url.URL) (*DeepCodeLLMBindingImpl, *mocks.MockHTTPClient) {
 	t.Helper()
 	ctrl := gomock.NewController(t)
 	mockHTTPClient := mocks.NewMockHTTPClient(ctrl)
@@ -84,14 +86,14 @@ func TestNewDeepcodeLLMBinding_Defaults(t *testing.T) {
 
 func TestWithHTTPClient(t *testing.T) {
 	client := http.NewHTTPClient(http.NewDefaultClientFactory())
-	binding := &DeepcodeLLMBinding{}
+	binding := &DeepCodeLLMBindingImpl{}
 	WithHTTPClient(func() http.HTTPClient { return client })(binding)
 	assert.Equal(t, client, binding.httpClientFunc())
 }
 
 func TestWithLogger(t *testing.T) {
 	logger := zerolog.Nop()
-	binding := &DeepcodeLLMBinding{}
+	binding := &DeepCodeLLMBindingImpl{}
 	WithLogger(&logger)(binding)
 	assert.Equal(t, &logger, binding.logger)
 }
@@ -104,7 +106,7 @@ func TestOutputFormatConstants(t *testing.T) {
 }
 
 func TestWithOutputFormat(t *testing.T) {
-	binding := &DeepcodeLLMBinding{}
+	binding := &DeepCodeLLMBindingImpl{}
 
 	// Test setting valid output formats
 	WithOutputFormat(JSON)(binding)
@@ -151,7 +153,7 @@ func TestWithEndpoint(t *testing.T) {
 				t.Fatalf("Failed to parse URL: %v", err)
 			}
 
-			binding := &DeepcodeLLMBinding{}
+			binding := &DeepCodeLLMBindingImpl{}
 			WithEndpoint(parsedURL)(binding)
 
 			if binding.endpoint.Scheme != tc.expected.Scheme {
@@ -172,15 +174,15 @@ func TestWithEndpoint(t *testing.T) {
 
 func TestWithInstrumentor(t *testing.T) {
 	// Test case 1:  Provide a mock instrumentor
-	binding := &DeepcodeLLMBinding{}
+	binding := &DeepCodeLLMBindingImpl{}
 
 	instrumentor := observability.NewInstrumentor()
 	WithInstrumentor(instrumentor)(binding)
 
 	assert.Equal(t, instrumentor, binding.instrumentor)
 
 	// Test case 2: Provide a nil instrumentor (should still set it)
-	binding = &DeepcodeLLMBinding{} // Reset binding for the next test
+	binding = &DeepCodeLLMBindingImpl{} // Reset binding for the next test
 
 	WithInstrumentor(nil)(binding)
 

llm/options.go

@@ -8,37 +8,37 @@ import (
 	"github.com/snyk/code-client-go/observability"
 )
 
-type Option func(*DeepcodeLLMBinding)
+type Option func(*DeepCodeLLMBindingImpl)
 
-func WithHTTPClient(httpClientFunc func() http.HTTPClient) func(*DeepcodeLLMBinding) {
-	return func(binding *DeepcodeLLMBinding) {
+func WithHTTPClient(httpClientFunc func() http.HTTPClient) func(*DeepCodeLLMBindingImpl) {
+	return func(binding *DeepCodeLLMBindingImpl) {
 		binding.httpClientFunc = httpClientFunc
 	}
 }
 
-func WithEndpoint(endpoint *url.URL) func(*DeepcodeLLMBinding) {
-	return func(binding *DeepcodeLLMBinding) {
+func WithEndpoint(endpoint *url.URL) func(*DeepCodeLLMBindingImpl) {
+	return func(binding *DeepCodeLLMBindingImpl) {
 		binding.endpoint = endpoint
 	}
 }
 
-func WithLogger(logger *zerolog.Logger) func(*DeepcodeLLMBinding) {
-	return func(binding *DeepcodeLLMBinding) {
+func WithLogger(logger *zerolog.Logger) func(*DeepCodeLLMBindingImpl) {
+	return func(binding *DeepCodeLLMBindingImpl) {
 		binding.logger = logger
 	}
 }
 
-func WithOutputFormat(outputFormat OutputFormat) func(*DeepcodeLLMBinding) {
-	return func(binding *DeepcodeLLMBinding) {
+func WithOutputFormat(outputFormat OutputFormat) func(*DeepCodeLLMBindingImpl) {
+	return func(binding *DeepCodeLLMBindingImpl) {
 		if outputFormat != HTML && outputFormat != JSON && outputFormat != MarkDown {
 			return
 		}
 		binding.outputFormat = outputFormat
 	}
 }
 
-func WithInstrumentor(instrumentor observability.Instrumentor) func(*DeepcodeLLMBinding) {
-	return func(binding *DeepcodeLLMBinding) {
+func WithInstrumentor(instrumentor observability.Instrumentor) func(*DeepCodeLLMBindingImpl) {
+	return func(binding *DeepCodeLLMBindingImpl) {
 		binding.instrumentor = instrumentor
 	}
 }