180 lines
6.4 KiB
Go
180 lines
6.4 KiB
Go
package format
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"go.maximumdirect.net/promptkit"
|
|
)
|
|
|
|
type PromptInspection struct {
|
|
PromptID string `json:"prompt_id"`
|
|
PromptHash string `json:"prompt_hash"`
|
|
DefaultProfileID *string `json:"default_profile_id,omitempty"`
|
|
Inputs *[]PromptInspectionInput `json:"inputs,omitempty"`
|
|
OutputContract OutputContract `json:"output_contract"`
|
|
}
|
|
|
|
type PromptInspectionInput struct {
|
|
Name string `json:"name"`
|
|
Required *bool `json:"required,omitempty"`
|
|
ContentType *string `json:"content_type,omitempty"`
|
|
Description *string `json:"description,omitempty"`
|
|
}
|
|
|
|
type OutputContract struct {
|
|
Format string `json:"format"`
|
|
ValidationMode string `json:"validation_mode"`
|
|
SchemaPath *string `json:"schema_path,omitempty"`
|
|
RepairAttempts *int `json:"repair_attempts,omitempty"`
|
|
}
|
|
|
|
type ProfileInspection struct {
|
|
ProfileID string `json:"profile_id"`
|
|
ProfileModelParams ProfileModelParams `json:"profile_model_params"`
|
|
APIKeyRequired *bool `json:"api_key_required,omitempty"`
|
|
}
|
|
|
|
type ProfileModelParams struct {
|
|
BackendID *string `json:"backend_id,omitempty"`
|
|
Endpoint *string `json:"endpoint,omitempty"`
|
|
Model *string `json:"model,omitempty"`
|
|
Temperature *float64 `json:"temperature,omitempty"`
|
|
MaxTokens *int `json:"max_tokens,omitempty"`
|
|
TopP *float64 `json:"top_p,omitempty"`
|
|
TimeoutSeconds *int `json:"timeout_seconds,omitempty"`
|
|
ServiceTier *string `json:"service_tier,omitempty"`
|
|
ReasoningEffort *string `json:"reasoning_effort,omitempty"`
|
|
APIKeyEnv *string `json:"api_key_env,omitempty"`
|
|
ExtraParams *map[string]any `json:"extra_params,omitempty"`
|
|
}
|
|
|
|
func FormatPromptInspection(value *promptkit.PromptInspection, outputFormat OutputFormat) ([]byte, error) {
|
|
if value == nil {
|
|
return nil, errors.New("prompt inspection is nil")
|
|
}
|
|
dto := PromptInspection{
|
|
PromptID: value.PromptID, PromptHash: value.PromptHash, DefaultProfileID: value.DefaultProfileID,
|
|
OutputContract: OutputContract{Format: string(value.OutputContract.Format), ValidationMode: string(value.OutputContract.ValidationMode), SchemaPath: value.OutputContract.SchemaPath, RepairAttempts: value.OutputContract.RepairAttempts},
|
|
}
|
|
if value.Inputs != nil {
|
|
inputs := make([]PromptInspectionInput, len(*value.Inputs))
|
|
for i, input := range *value.Inputs {
|
|
inputs[i] = PromptInspectionInput{Name: input.Name, Required: input.Required, ContentType: input.ContentType, Description: input.Description}
|
|
}
|
|
dto.Inputs = &inputs
|
|
}
|
|
switch outputFormat {
|
|
case OutputFormatJSON:
|
|
data, err := json.MarshalIndent(dto, "", " ")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return append(data, '\n'), nil
|
|
case OutputFormatText:
|
|
var b bytes.Buffer
|
|
fmt.Fprintf(&b, "prompt_id: %s\nprompt_hash: %s\n", dto.PromptID, dto.PromptHash)
|
|
if dto.DefaultProfileID != nil {
|
|
fmt.Fprintf(&b, "default_profile_id: %s\n", *dto.DefaultProfileID)
|
|
}
|
|
if dto.Inputs != nil {
|
|
if len(*dto.Inputs) == 0 {
|
|
fmt.Fprintln(&b, "inputs: []")
|
|
} else {
|
|
fmt.Fprintln(&b, "inputs:")
|
|
for _, input := range *dto.Inputs {
|
|
fmt.Fprintf(&b, " - name: %s\n", input.Name)
|
|
if input.Required != nil {
|
|
fmt.Fprintf(&b, " required: %t\n", *input.Required)
|
|
}
|
|
if input.ContentType != nil {
|
|
fmt.Fprintf(&b, " content_type: %s\n", *input.ContentType)
|
|
}
|
|
if input.Description != nil {
|
|
fmt.Fprintf(&b, " description: %s\n", strconv.Quote(*input.Description))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fmt.Fprintf(&b, "output_contract:\n format: %s\n validation_mode: %s\n", dto.OutputContract.Format, dto.OutputContract.ValidationMode)
|
|
if dto.OutputContract.SchemaPath != nil {
|
|
fmt.Fprintf(&b, " schema_path: %s\n", *dto.OutputContract.SchemaPath)
|
|
}
|
|
if dto.OutputContract.RepairAttempts != nil {
|
|
fmt.Fprintf(&b, " repair_attempts: %d\n", *dto.OutputContract.RepairAttempts)
|
|
}
|
|
return b.Bytes(), nil
|
|
default:
|
|
return nil, fmt.Errorf("%w: %q", ErrUnknownPreparedRunFormat, outputFormat)
|
|
}
|
|
}
|
|
|
|
func FormatProfileInspection(value *promptkit.ProfileInspection, outputFormat OutputFormat) ([]byte, error) {
|
|
if value == nil {
|
|
return nil, errors.New("profile inspection is nil")
|
|
}
|
|
dto := ProfileInspection{ProfileID: value.ProfileID, APIKeyRequired: value.APIKeyRequired, ProfileModelParams: ProfileModelParams{
|
|
BackendID: value.Backend, Endpoint: value.Endpoint, Model: value.Model, Temperature: value.Temperature,
|
|
MaxTokens: value.MaxTokens, TopP: value.TopP, TimeoutSeconds: value.TimeoutSeconds, ServiceTier: value.ServiceTier,
|
|
ReasoningEffort: value.ReasoningEffort, APIKeyEnv: value.APIKeyEnv, ExtraParams: value.ExtraParams,
|
|
}}
|
|
switch outputFormat {
|
|
case OutputFormatJSON:
|
|
data, err := json.MarshalIndent(dto, "", " ")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return append(data, '\n'), nil
|
|
case OutputFormatText:
|
|
var b bytes.Buffer
|
|
fmt.Fprintf(&b, "profile_id: %s\nprofile_model_params:\n", dto.ProfileID)
|
|
p := dto.ProfileModelParams
|
|
if p.BackendID != nil {
|
|
fmt.Fprintf(&b, " backend_id: %s\n", *p.BackendID)
|
|
}
|
|
if p.Endpoint != nil {
|
|
fmt.Fprintf(&b, " endpoint: %s\n", *p.Endpoint)
|
|
}
|
|
if p.Model != nil {
|
|
fmt.Fprintf(&b, " model: %s\n", *p.Model)
|
|
}
|
|
if p.Temperature != nil {
|
|
fmt.Fprintf(&b, " temperature: %g\n", *p.Temperature)
|
|
}
|
|
if p.MaxTokens != nil {
|
|
fmt.Fprintf(&b, " max_tokens: %d\n", *p.MaxTokens)
|
|
}
|
|
if p.TopP != nil {
|
|
fmt.Fprintf(&b, " top_p: %g\n", *p.TopP)
|
|
}
|
|
if p.TimeoutSeconds != nil {
|
|
fmt.Fprintf(&b, " timeout_seconds: %d\n", *p.TimeoutSeconds)
|
|
}
|
|
if p.ServiceTier != nil {
|
|
fmt.Fprintf(&b, " service_tier: %s\n", *p.ServiceTier)
|
|
}
|
|
if p.ReasoningEffort != nil {
|
|
fmt.Fprintf(&b, " reasoning_effort: %s\n", *p.ReasoningEffort)
|
|
}
|
|
if p.APIKeyEnv != nil {
|
|
fmt.Fprintf(&b, " api_key_env: %s\n", *p.APIKeyEnv)
|
|
}
|
|
if p.ExtraParams != nil {
|
|
paramsJSON, err := json.Marshal(p.ExtraParams)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Fprintf(&b, " extra_params: %s\n", paramsJSON)
|
|
}
|
|
if dto.APIKeyRequired != nil {
|
|
fmt.Fprintf(&b, "api_key_required: %t\n", *dto.APIKeyRequired)
|
|
}
|
|
return b.Bytes(), nil
|
|
default:
|
|
return nil, fmt.Errorf("%w: %q", ErrUnknownPreparedRunFormat, outputFormat)
|
|
}
|
|
}
|