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) } }