promptkit/convert.go

package promptkit

import (
	"fmt"
	"unicode/utf8"

	"go.maximumdirect.net/promptkit/internal/configuration"
	"go.maximumdirect.net/promptkit/internal/domain"
	"go.maximumdirect.net/promptkit/internal/jsonvalue"
)

func toDomainRunRequest(req RunRequest) (domain.RunRequest, error) {
	execution, err := toDomainExecutionTargetOverride(req.Execution)
	if err != nil {
		return domain.RunRequest{}, err
	}
	appendedMessages, err := toDomainAppendedMessages(req.AppendedMessages)
	if err != nil {
		return domain.RunRequest{}, err
	}
	var observer domain.ExecutionObserver
	if req.Observer != nil {
		callback := req.Observer
		observer = func(event domain.ExecutionEvent) { callback(fromDomainExecutionEvent(event)) }
	}
	return domain.RunRequest{
		PromptID:         req.PromptID,
		ProfileID:        req.ProfileID,
		SessionID:        req.SessionID,
		APIKey:           req.APIKey,
		Inputs:           toDomainArtifactRefMap(req.Inputs),
		Vars:             copyStringMap(req.Vars),
		Execution:        execution,
		Validation:       toDomainOutputContractPtr(req.Validation),
		AppendedMessages: appendedMessages,
		TransientRetries: copyIntPtr(req.TransientRetries),
		Observer:         observer,
	}, nil
}

func toDomainAppendedMessages(messages []RenderedMessage) ([]domain.RenderedMessage, error) {
	if messages == nil {
		return nil, nil
	}

	converted := make([]domain.RenderedMessage, len(messages))
	for index, message := range messages {
		if !utf8.ValidString(message.Content) {
			return nil, fmt.Errorf("appended message %d content must be valid UTF-8", index)
		}
		role, err := domain.NormalizeMessageRole(message.Role)
		if err != nil {
			return nil, fmt.Errorf("appended message %d role: %w", index, err)
		}

		cacheControl, err := domain.NormalizeCacheControl(toDomainCacheControl(message.CacheControl))
		if err != nil {
			return nil, fmt.Errorf("appended message %d cache_control: %w", index, err)
		}
		converted[index] = domain.RenderedMessage{
			Role:         role,
			Content:      message.Content,
			CacheControl: cacheControl,
		}
	}
	return converted, nil
}

func fromDomainPreparedRun(prepared *domain.PreparedRun) *PreparedRun {
	if prepared == nil {
		return nil
	}
	return &PreparedRun{
		PromptID:             prepared.PromptID,
		PromptHash:           prepared.PromptHash,
		SelectedProfileID:    prepared.SelectedProfileID,
		SelectedBackendID:    prepared.SelectedBackendID,
		EffectiveModelParams: fromDomainExecutionTarget(prepared.EffectiveModelParams),
		OutputContract:       fromDomainOutputContract(prepared.OutputContract),
		StructuredOutput:     fromDomainStructuredOutputSpec(prepared.StructuredOutput),
		InputHashes:          copyStringMap(prepared.InputHashes),
		SessionID:            prepared.SessionID,
		RenderedPromptHash:   prepared.RenderedPromptHash,
		Messages:             fromDomainRenderedMessages(prepared.Messages),
		StartTime:            prepared.StartTime,
		EndTime:              prepared.EndTime,
		DurationMS:           prepared.DurationMS,
	}
}

func fromDomainRunResult(result *domain.RunResult) *RunResult {
	if result == nil {
		return nil
	}
	return &RunResult{
		RunID:                result.RunID,
		Artifact:             fromDomainArtifact(result.Artifact),
		RawOutput:            result.RawOutput,
		Validation:           fromDomainValidationResult(result.Validation),
		PromptID:             result.PromptID,
		PromptHash:           result.PromptHash,
		SessionID:            result.SessionID,
		RenderedPromptHash:   result.RenderedPromptHash,
		SelectedProfileID:    result.SelectedProfileID,
		SelectedBackendID:    result.SelectedBackendID,
		ModelName:            result.ModelName,
		Endpoint:             result.Endpoint,
		EffectiveModelParams: fromDomainExecutionTarget(result.EffectiveModelParams),
		InputHashes:          copyStringMap(result.InputHashes),
		Usage:                fromDomainTokenUsage(result.Usage),
		StartTime:            result.StartTime,
		EndTime:              result.EndTime,
		Duration:             result.Duration,
	}
}

func fromDomainGenerateRequest(req domain.GenerateRequest) GenerateRequest {
	return GenerateRequest{
		Prompt:           fromDomainRenderedPrompt(req.Prompt),
		Target:           fromDomainExecutionTarget(req.Target),
		TargetPresence:   fromDomainExecutionTargetPresence(req.TargetPresence),
		StructuredOutput: fromDomainStructuredOutputSpec(req.StructuredOutput),
		APIKey:           req.Target.APIKey,
	}
}

func toDomainGenerateResponse(resp *GenerateResponse) *domain.GenerateResponse {
	if resp == nil {
		return nil
	}
	return &domain.GenerateResponse{
		Content:       resp.Content,
		Usage:         toDomainTokenUsage(resp.Usage),
		UsagePresence: toDomainTokenUsagePresence(resp.UsagePresence),
	}
}

func toDomainTokenUsagePresence(presence *TokenUsagePresence) *domain.TokenUsagePresence {
	if presence == nil {
		return nil
	}
	return &domain.TokenUsagePresence{
		PromptTokens:     presence.PromptTokens,
		CompletionTokens: presence.CompletionTokens,
		TotalTokens:      presence.TotalTokens,
		CachedTokens:     presence.CachedTokens,
		CacheWriteTokens: presence.CacheWriteTokens,
	}
}

func fromDomainRenderedPrompt(prompt domain.RenderedPrompt) RenderedPrompt {
	return RenderedPrompt{
		SessionID: prompt.SessionID,
		Messages:  fromDomainRenderedMessages(prompt.Messages),
	}
}

func toDomainArtifactRefMap(src map[string]ArtifactRef) map[string]domain.ArtifactRef {
	if src == nil {
		return nil
	}
	out := make(map[string]domain.ArtifactRef, len(src))
	for k, v := range src {
		out[k] = toDomainArtifactRef(v)
	}
	return out
}

func toDomainArtifactRef(ref ArtifactRef) domain.ArtifactRef {
	return domain.ArtifactRef{
		Type: domain.ArtifactRefType(ref.Type),
		URI:  ref.URI,
		Body: ref.Body,
	}
}

func fromDomainArtifact(artifact domain.Artifact) Artifact {
	return Artifact{
		Name:        artifact.Name,
		ContentType: artifact.ContentType,
		Body:        copyBytes(artifact.Body),
		URI:         artifact.URI,
		Size:        artifact.Size,
		Hash:        artifact.Hash,
	}
}

func toDomainExecutionTargetOverride(override *ExecutionTargetOverride) (*domain.ExecutionTargetOverride, error) {
	if override == nil {
		return nil, nil
	}
	extraParams, err := jsonvalue.CopyMap(override.ExtraParams)
	if err != nil {
		return nil, err
	}
	return &domain.ExecutionTargetOverride{
		Endpoint:        override.Endpoint,
		Model:           override.Model,
		Temperature:     copyFloat64Ptr(override.Temperature),
		MaxTokens:       copyIntPtr(override.MaxTokens),
		TopP:            copyFloat64Ptr(override.TopP),
		TimeoutSeconds:  copyIntPtr(override.TimeoutSeconds),
		ServiceTier:     override.ServiceTier,
		ReasoningEffort: copyStringPtr(override.ReasoningEffort),
		APIKeyEnv:       override.APIKeyEnv,
		ExtraParams:     extraParams,
	}, nil
}

func fromDomainExecutionTarget(target domain.ExecutionTarget) ExecutionTarget {
	return fromDomainExecutionTargetWithOwnedParams(target, copyAnyMap(target.ExtraParams))
}

// fromDomainExecutionTargetWithOwnedParams projects scalar settings and takes
// ownership of extraParams, which the caller has already copied.
func fromDomainExecutionTargetWithOwnedParams(target domain.ExecutionTarget, extraParams map[string]any) ExecutionTarget {
	return ExecutionTarget{
		BackendID:       target.BackendID,
		Endpoint:        target.Endpoint,
		Model:           target.Model,
		Temperature:     target.Temperature,
		MaxTokens:       target.MaxTokens,
		TopP:            target.TopP,
		TimeoutSeconds:  target.TimeoutSeconds,
		ServiceTier:     target.ServiceTier,
		ReasoningEffort: target.ReasoningEffort,
		APIKeyEnv:       target.APIKeyEnv,
		ExtraParams:     extraParams,
	}
}

func fromProfileResource(v *configuration.ProfileResource) *ProfileInspection {
	out := &ProfileInspection{ProfileID: v.ID, Backend: copyStringPtr(v.Backend), Endpoint: copyStringPtr(v.Endpoint), Model: copyStringPtr(v.Model), Temperature: copyFloat64Ptr(v.Temperature), TopP: copyFloat64Ptr(v.TopP), MaxTokens: copyIntPtr(v.MaxTokens), TimeoutSeconds: copyIntPtr(v.TimeoutSeconds), ServiceTier: copyStringPtr(v.ServiceTier), ReasoningEffort: copyStringPtr(v.ReasoningEffort), APIKeyEnv: copyStringPtr(v.APIKeyEnv), APIKeyRequired: copyBoolPtr(v.APIKeyRequired)}
	if v.ExtraParams != nil {
		data := copyAnyMap(v.ExtraParams)
		out.ExtraParams = &data
	}
	return out
}

func fromBackendResource(v *configuration.BackendResource) *BackendInspection {
	out := &BackendInspection{BackendID: v.ID, Endpoint: v.Endpoint, APIKeyEnv: copyStringPtr(v.APIKeyEnv), ConcurrencyLimit: copyIntPtr(v.ConcurrencyLimit), QueueCapacity: copyIntPtr(v.QueueCapacity)}
	if v.ExtraParams != nil {
		data := copyAnyMap(v.ExtraParams)
		out.ExtraParams = &data
	}
	if v.SmokeTests != nil {
		out.SmokeTests = &BackendSmokeTestConfig{DefaultProfile: copyStringPtr(v.SmokeTests.DefaultProfile)}
		if v.SmokeTests.Reachability != nil {
			out.SmokeTests.Reachability = &ReachabilityProbeConfig{Endpoint: copyStringPtr(v.SmokeTests.Reachability.Endpoint)}
		}
		if v.SmokeTests.Authentication != nil {
			out.SmokeTests.Authentication = &AuthenticationProbeConfig{Kind: copyStringPtr(v.SmokeTests.Authentication.Kind), Endpoint: copyStringPtr(v.SmokeTests.Authentication.Endpoint)}
		}
	}
	return out
}

func fromPromptResource(v *configuration.PromptResource) *PromptInspection {
	out := &PromptInspection{PromptID: v.ID, PromptHash: v.Hash, DefaultProfileID: copyStringPtr(v.DefaultProfile), Description: copyStringPtr(v.Description), SessionID: copyStringPtr(v.SessionID), OutputContract: PromptOutputInspection{Format: OutputFormat(v.Output.Format), ValidationMode: ValidationMode(v.Output.ValidationMode), SchemaPath: copyStringPtr(v.Output.SchemaPath), RepairAttempts: copyIntPtr(v.Output.RepairAttempts)}}
	if v.Inputs != nil {
		inputs := make([]PromptInputInspection, len(*v.Inputs))
		for i, input := range *v.Inputs {
			inputs[i] = PromptInputInspection{Name: input.Name, Required: copyBoolPtr(input.Required), ContentType: copyStringPtr(input.ContentType), Description: copyStringPtr(input.Description)}
		}
		out.Inputs = &inputs
	}
	out.Messages = make([]PromptMessageInspection, len(v.Messages))
	for i, message := range v.Messages {
		out.Messages[i] = PromptMessageInspection{Role: message.Role, Content: message.Content}
		if message.CacheControl != nil {
			out.Messages[i].CacheControl = &PromptCacheControlInspection{Type: CacheControlType(message.CacheControl.Type), TTL: copyStringPtr(message.CacheControl.TTL)}
		}
	}
	return out
}

func copyBoolPtr(src *bool) *bool {
	if src == nil {
		return nil
	}
	value := *src
	return &value
}

func fromDomainExecutionTargetPresence(presence domain.ExecutionTargetPresence) ExecutionTargetPresence {
	return ExecutionTargetPresence{
		Temperature:    presence.Temperature,
		MaxTokens:      presence.MaxTokens,
		TopP:           presence.TopP,
		TimeoutSeconds: presence.TimeoutSeconds,
	}
}

func toDomainOutputContractPtr(contract *OutputContract) *domain.OutputContract {
	if contract == nil {
		return nil
	}
	out := toDomainOutputContract(*contract)
	return &out
}

func toDomainOutputContract(contract OutputContract) domain.OutputContract {
	return domain.OutputContract{
		Format:         domain.OutputFormat(contract.Format),
		ValidationMode: domain.ValidationMode(contract.ValidationMode),
		SchemaPath:     contract.SchemaPath,
		RepairAttempts: contract.RepairAttempts,
	}
}

func fromDomainOutputContract(contract domain.OutputContract) OutputContract {
	return OutputContract{
		Format:         OutputFormat(contract.Format),
		ValidationMode: ValidationMode(contract.ValidationMode),
		SchemaPath:     contract.SchemaPath,
		RepairAttempts: contract.RepairAttempts,
	}
}

func fromDomainValidationResult(result domain.ValidationResult) ValidationResult {
	return ValidationResult{
		Status:         ValidationStatus(result.Status),
		Mode:           ValidationMode(result.Mode),
		Errors:         copyStringSlice(result.Errors),
		SchemaPath:     result.SchemaPath,
		RepairAttempts: result.RepairAttempts,
		IsValid:        result.IsValid,
	}
}

func fromDomainTokenUsage(usage domain.TokenUsage) TokenUsage {
	return TokenUsage{
		PromptTokens:     usage.PromptTokens,
		CompletionTokens: usage.CompletionTokens,
		TotalTokens:      usage.TotalTokens,
		CachedTokens:     usage.CachedTokens,
		CacheWriteTokens: usage.CacheWriteTokens,
	}
}

func toDomainTokenUsage(usage TokenUsage) domain.TokenUsage {
	return domain.TokenUsage{
		PromptTokens:     usage.PromptTokens,
		CompletionTokens: usage.CompletionTokens,
		TotalTokens:      usage.TotalTokens,
		CachedTokens:     usage.CachedTokens,
		CacheWriteTokens: usage.CacheWriteTokens,
	}
}

func fromDomainRenderedMessages(messages []domain.RenderedMessage) []RenderedMessage {
	if messages == nil {
		return nil
	}
	out := make([]RenderedMessage, len(messages))
	for i, msg := range messages {
		out[i] = RenderedMessage{
			Role:         msg.Role,
			Content:      msg.Content,
			CacheControl: fromDomainCacheControl(msg.CacheControl),
		}
	}
	return out
}

func toDomainCacheControl(cacheControl *CacheControl) *domain.CacheControl {
	if cacheControl == nil {
		return nil
	}
	return &domain.CacheControl{
		Type: domain.CacheControlType(cacheControl.Type),
		TTL:  cacheControl.TTL,
	}
}

func fromDomainCacheControl(cacheControl *domain.CacheControl) *CacheControl {
	if cacheControl == nil {
		return nil
	}
	return &CacheControl{
		Type: CacheControlType(cacheControl.Type),
		TTL:  cacheControl.TTL,
	}
}

func fromDomainStructuredOutputSpec(spec *domain.StructuredOutputSpec) *StructuredOutputSpec {
	if spec == nil {
		return nil
	}
	out := &StructuredOutputSpec{
		Type: StructuredOutputType(spec.Type),
	}
	if spec.JSONSchema != nil {
		out.JSONSchema = &StructuredOutputJSONSpec{
			Name:   spec.JSONSchema.Name,
			Strict: spec.JSONSchema.Strict,
			Schema: copyAny(spec.JSONSchema.Schema),
		}
	}
	return out
}

func copyStringMap(src map[string]string) map[string]string {
	if src == nil {
		return nil
	}
	out := make(map[string]string, len(src))
	for k, v := range src {
		out[k] = v
	}
	return out
}

func copyAnyMap(src map[string]any) map[string]any {
	if src == nil {
		return nil
	}
	return jsonvalue.CloneTrusted(src).(map[string]any)
}

func copyAny(value any) any { return jsonvalue.CloneTrusted(value) }

func copyStringSlice(src []string) []string {
	if src == nil {
		return nil
	}
	out := make([]string, len(src))
	copy(out, src)
	return out
}

func copyBytes(src []byte) []byte {
	if src == nil {
		return nil
	}
	out := make([]byte, len(src))
	copy(out, src)
	return out
}

func copyFloat64Ptr(src *float64) *float64 {
	if src == nil {
		return nil
	}
	v := *src
	return &v
}

func copyStringPtr(src *string) *string {
	if src == nil {
		return nil
	}
	v := *src
	return &v
}

func copyIntPtr(src *int) *int {
	if src == nil {
		return nil
	}
	v := *src
	return &v
}