broken back of fag packet code for langwatch go intergration

Author: 0xdeafcafe

libraries/langwatch/README.md

@@ -0,0 +1,61 @@
+# langwatch-go
+
+This is a Go client for the [Langwatch 🏰](https://langwatch.ai) API.
+
+## Feature set
+
+| Feature name | Supported |
+| ------------ | --------- |
+| LLM Spans    | Partial   |
+| RAG Spans    | 🚫        |
+
+## Usage
+
+```go
+package main
+
+import (
+	"github.com/0xdeafcafe/bloefish/libraries/langwatch"
+	"github.com/0xdeafcafe/bloefish/libraries/ksuid"
+	"github.com/0xdeafcafe/bloefish/libraries/openai"
+)
+
+var client langwatch.Client
+var oaiClient openai.MockClient
+
+func init() {
+	ctx := context.Background()
+	client = langwatch.NewClient()
+	oaiClient = openai.NewMockClient()
+
+	threadID := ksuid.Generate(ctx, "thread").String()
+	userID := ksuid.Generate(ctx, "user").String()
+
+	// Create a trace
+	ctx, trace := client.CreateTrace(ctx, threadID, langwatch.WithTraceMetadata(
+		langwatch.Attribute("user_id", userID),
+		langwatch.Attribute("app_id", "AppID"),
+		langwatch.Attribute("app_version", "1.0.0"),
+	))
+	defer trace.End()
+
+	messages := createOpenAIMessages()
+
+	ctx, span := trace.StartLLMSpan(ctx, langwatch.StartLLMSpanCommand{
+		Name: "llm",
+		Model: "gpt-4.0",
+		Messages: langwatch.CoerceOpenAIMessages(messages),
+		// Messages: langwatch.CoerceGrokMessages(messages),
+		// Messages: langwatch.CoerceDeepseekMessages(messages),
+	})
+	defer span.End()
+
+	span.AddOutput(ctx, langwatch.LLMSpanOutput{
+		Output: 
+	})
+
+	// Create a span
+
+
+}
+```

libraries/langwatch/attirbute.go

@@ -0,0 +1,19 @@
+package langwatch
+
+const (
+	AttributeNameUserID     = "user_id"
+	AttributeNameThreadID   = "thread_id"
+	AttributeNameCustomerID = "customer_id"
+)
+
+type attribute[T any] struct {
+	Name  string
+	Value T
+}
+
+func Attribute[T any](name string, value T) attribute[any] {
+	return attribute[any]{
+		Name:  name,
+		Value: value,
+	}
+}

libraries/langwatch/client.go

@@ -0,0 +1,62 @@
+package langwatch
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+)
+
+const (
+	defaultEndpointURL                   = "https://app.langwatch.ai"
+	defaultAPIKeyEnvironmentVariableName = "LANGWATCH_API_KEY"
+)
+
+type client struct {
+	endpointURL string
+	apiKey      string
+	httpClient  *http.Client
+}
+
+type Client interface {
+	CreateTrace(ctx context.Context, threadID string, opts ...TraceOption) (context.Context, Trace)
+}
+
+func NewClient(opts ...ClientOption) Client {
+	c := &client{
+		endpointURL: defaultEndpointURL,
+		apiKey:      os.Getenv(defaultAPIKeyEnvironmentVariableName),
+		httpClient:  &http.Client{},
+	}
+
+	for _, opt := range opts {
+		opt(c)
+	}
+
+	return c
+}
+
+func (c *client) Collect(ctx context.Context, body interface{}) error {
+	jsonBytes, err := json.Marshal(body)
+	if err != nil {
+		return fmt.Errorf("failed to marshal collector request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.endpointURL+"/api/collector", bytes.NewReader(jsonBytes))
+	if err != nil {
+		return fmt.Errorf("failed to create collector request: %w", err)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to make collector request: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("failed to successfully make collector request: %w", err)
+	}
+
+	return nil
+}

libraries/langwatch/context.go

@@ -0,0 +1 @@
+package langwatch

libraries/langwatch/langwatch.go

@@ -0,0 +1,24 @@
+package langwatch
+
+import "context"
+
+type noopClient struct{}
+type noopTrace struct{}
+type noopSpanLLM struct{}
+
+func NewNoopClient() Client {
+	return &noopClient{}
+}
+
+func (c *noopClient) CreateTrace(ctx context.Context, theadID string, _ ...TraceOption) (context.Context, Trace) {
+	t := &noopTrace{}
+
+	return ctx, t
+}
+
+func (t *noopTrace) StartLLMSpan(ctx context.Context, _ StartLLMSpanParams) (context.Context, SpanLLM) {
+	return ctx, &noopSpanLLM{}
+}
+
+func (s *noopSpanLLM) AddOutput(ctx context.Context) {}
+func (s *noopSpanLLM) End(ctx context.Context)       {}

libraries/langwatch/noop.go

@@ -0,0 +1,45 @@
+package langwatch
+
+import (
+	"net/http"
+	"os"
+)
+
+type ClientOption func(*client)
+type TraceOption func(*trace)
+
+// WithEndpointURL sets a custom endpoint URL for the client. By default
+// `defaultEndpointURL` is used.
+func WithEndpointURL(endpoint string) ClientOption {
+	return func(c *client) {
+		c.endpointURL = endpoint
+	}
+}
+
+// WithAPIKey sets the API key for the client.
+func WithAPIKey(apiKey string) ClientOption {
+	return func(c *client) {
+		c.apiKey = apiKey
+	}
+}
+
+// WithEnvironmentApiKey sets the API key for the client from an environment variable.
+func WithEnvironmentApiKey(environmentVariable string) ClientOption {
+	return func(c *client) {
+		c.apiKey = os.Getenv(environmentVariable)
+	}
+}
+
+// WithHTTPClient sets the http client for the client.
+func WithHTTPClient(httpClient *http.Client) ClientOption {
+	return func(c *client) {
+		c.httpClient = httpClient
+	}
+}
+
+// WithTraceMetadata sets attributes on a trace to attach as metadata.
+func WithTraceMetadata(attributes ...attribute[any]) TraceOption {
+	return func(t *trace) {
+		t.attributes = attributes
+	}
+}

libraries/langwatch/options.go

@@ -0,0 +1,132 @@
+package langwatch
+
+import (
+	"context"
+	"time"
+
+	"github.com/0xdeafcafe/bloefish/libraries/ptr"
+)
+
+type SpanLLM interface {
+	AddOutput(ctx context.Context, output string)
+	AddError(ctx context.Context, err error)
+	End(ctx context.Context)
+}
+
+type LLMSpanInputChatMessage struct {
+	Role    string `json:"role"`
+	Message string `json:"message"`
+}
+
+type LLMSpanOutputChatMessage struct {
+	Role         string        `json:"role"`
+	Message      string        `json:"message"`
+	FunctionCall interface{}   `json:"function_call"`
+	ToolCalls    []interface{} `json:"tool_calls"`
+}
+
+type StartLLMSpanParams struct {
+	Vendor string
+	Model  string
+	Name   *string
+	Input  StartLLMSpanChatMessageInput
+}
+
+type StartLLMSpanChatMessageInput struct {
+	Messages []LLMSpanInputChatMessage
+}
+
+type spanLLM struct {
+	client     *client
+	trace      Trace
+	spanID     string
+	name       *string
+	vendor     *string
+	model      *string
+	input      *spanLLMInput
+	output     *spanLLMOutput
+	error      error
+	timestamps *spanLLMTimestamps
+	metrics    *spanLLMMetrics
+}
+
+type spanLLMInput struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value"`
+}
+type spanLLMOutput struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value"`
+}
+type spanLLMParams struct {
+	Temperature *float64 `json:"temperature,omitempty"`
+	Stream      *bool    `json:"stream,omitempty"`
+}
+type spanLLMTimestamps struct {
+	StartedAt  *int64 `json:"started_at,omitempty"`
+	FinishedAt *int64 `json:"finished_at,omitempty"`
+}
+type spanLLMMetrics struct {
+	PromptTokens     *int `json:"prompt_tokens,omitempty"`
+	CompletionTokens *int `json:"completion_tokens,omitempty"`
+}
+
+type spanCollectorRequest struct {
+	TraceID  string                      `json:"trace_id"`
+	Spans    []*spanCollectorRequestSpan `json:"spans"`
+	Metadata map[string]string           `json:"metadata"`
+}
+type spanCollectorRequestSpan struct {
+	Type       string
+	SpanID     string
+	Vendor     string
+	Model      string
+	Input      interface{}
+	Output     interface{}
+	Params     interface{}
+	Metrics    interface{}
+	Timestamps interface{}
+}
+type spanCollectorRequestMetadata struct {
+}
+
+func (t *trace) StartLLMSpan(ctx context.Context, spanID string, params StartLLMSpanParams) (context.Context, SpanLLM) {
+	return ctx, &spanLLM{
+		client: t.client,
+		trace:  t,
+
+		spanID: spanID,
+		vendor: &params.Vendor,
+		model:  &params.Model,
+
+		input: &spanLLMInput{
+			Type:  "chat_messages",
+			Value: params.Input.Messages,
+		},
+
+		timestamps: &spanLLMTimestamps{
+			StartedAt: ptr.P(time.Now().UnixNano()),
+		},
+	}
+}
+
+func (s *spanLLM) AddOutput(ctx context.Context, output string) {
+	s.output = &spanLLMOutput{
+		Type: "chat_messages",
+		Value: []LLMSpanOutputChatMessage{{
+			Role:         "bot",
+			Message:      output,
+			FunctionCall: nil,
+			ToolCalls:    []interface{}{},
+		}},
+	}
+	s.timestamps.FinishedAt = ptr.P(time.Now().UnixNano())
+}
+
+func (s *spanLLM) AddError(ctx context.Context, err error) {
+	s.error = err
+}
+
+func (s *spanLLM) End(ctx context.Context) {
+	s.client.Collect(ctx)
+}

libraries/langwatch/span_llm.go

@@ -0,0 +1,25 @@
+package langwatch
+
+import "context"
+
+type Trace interface {
+	StartLLMSpan(ctx context.Context, spanID string, params StartLLMSpanParams) (context.Context, SpanLLM)
+}
+
+type trace struct {
+	attributes []attribute[any]
+	client     *client
+}
+
+func (c *client) CreateTrace(ctx context.Context, theadID string, opts ...TraceOption) (context.Context, Trace) {
+	t := &trace{
+		attributes: []attribute[any]{},
+		client:     c,
+	}
+
+	for _, opt := range opts {
+		opt(t)
+	}
+
+	return ctx, t
+}