feat: add textInference command for LLM text generation

Supports sync delivery with messages-based API, system prompts,
temperature/topP/topK sampling, and pipe-friendly text output.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: chris-anstey-runware

cmd/root.go

@@ -50,6 +50,7 @@ func init() {
 	rootCmd.AddCommand(imageInferenceCmd)
 	rootCmd.AddCommand(videoInferenceCmd)
 	rootCmd.AddCommand(audioInferenceCmd)
+	rootCmd.AddCommand(textInferenceCmd)
 	rootCmd.AddCommand(modelSearchCmd)
 	rootCmd.AddCommand(accountCmd)
 	rootCmd.AddCommand(configCmd)

cmd/text_inference.go

@@ -0,0 +1,199 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/briandowns/spinner"
+	"github.com/runware/runware-cli/internal/api"
+	"github.com/runware/runware-cli/internal/config"
+	"github.com/runware/runware-cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+var textInferenceCmd = &cobra.Command{
+	Use:   "textInference [message]",
+	Short: "Generate text using a language model",
+	Long: `Send a message to a language model and get a text response.
+
+Examples:
+  runware textInference "What is the capital of France?"
+  runware textInference "Explain quantum computing" --model runware:qwen3-thinking@1 --max-tokens 500
+  runware textInference "Write a haiku about coding" --system "You are a poet" --temperature 0.8
+  runware textInference "List 3 facts about Mars" --output-format json`,
+	Args: cobra.ExactArgs(1),
+	RunE: runTextInference,
+}
+
+func init() {
+	f := textInferenceCmd.Flags()
+	f.String("model", "", "Model identifier (e.g. runware:qwen3-thinking@1)")
+	f.String("system", "", "System prompt")
+	f.Int("max-tokens", 0, "Maximum tokens in response (1-128000)")
+	f.Float64("temperature", 0, "Sampling temperature (0-2)")
+	f.Float64("top-p", 0, "Nucleus sampling parameter (0-1)")
+	f.Int("top-k", 0, "Top-k sampling parameter (1-100)")
+	f.Int64("seed", 0, "Random seed for reproducibility")
+	f.StringSlice("stop", nil, "Stop sequences (max 5)")
+	f.Int("count", 1, "Number of results to generate (1-4)")
+	f.String("output-format", "", "LLM output format: text or json")
+	f.Bool("include-cost", false, "Include cost info in response")
+	f.String("preset", "", "Named preset to apply")
+	f.Bool("dry-run", false, "Print the API request without executing")
+
+	_ = textInferenceCmd.RegisterFlagCompletionFunc("output-format", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return []string{"text", "json"}, cobra.ShellCompDirectiveNoFileComp
+	})
+
+	_ = textInferenceCmd.RegisterFlagCompletionFunc("preset", completePresetNames)
+}
+
+func runTextInference(cmd *cobra.Command, args []string) error {
+	key := config.GetAPIKey()
+	if key == "" {
+		output.Error("No API key configured. Run 'runware auth login' to authenticate.")
+		return api.ErrNoAPIKey
+	}
+
+	cfg := config.Get()
+	message := args[0]
+
+	model := cfg.Defaults.Model
+
+	// Apply preset if specified
+	presetName, _ := cmd.Flags().GetString("preset")
+	if presetName != "" {
+		preset := config.GetPreset(presetName)
+		if preset == nil {
+			return fmt.Errorf("preset '%s' not found", presetName)
+		}
+		if preset.Model != "" {
+			model = preset.Model
+		}
+	}
+
+	// Override with explicit CLI flags
+	if cmd.Flags().Changed("model") {
+		model, _ = cmd.Flags().GetString("model")
+	}
+
+	systemPrompt, _ := cmd.Flags().GetString("system")
+	maxTokens, _ := cmd.Flags().GetInt("max-tokens")
+	temperature, _ := cmd.Flags().GetFloat64("temperature")
+	topP, _ := cmd.Flags().GetFloat64("top-p")
+	topK, _ := cmd.Flags().GetInt("top-k")
+	seed, _ := cmd.Flags().GetInt64("seed")
+	stopSequences, _ := cmd.Flags().GetStringSlice("stop")
+	count, _ := cmd.Flags().GetInt("count")
+	outputFmt, _ := cmd.Flags().GetString("output-format")
+	includeCost, _ := cmd.Flags().GetBool("include-cost")
+	dryRun, _ := cmd.Flags().GetBool("dry-run")
+
+	// Build request
+	req := &api.TextInferenceRequest{
+		TaskType: "textInference",
+		TaskUUID: api.NewUUID(),
+		Model:    model,
+		Messages: []api.Message{
+			{Role: "user", Content: message},
+		},
+		IncludeCost: includeCost,
+	}
+
+	if systemPrompt != "" {
+		req.SystemPrompt = systemPrompt
+	}
+	if maxTokens > 0 {
+		req.MaxTokens = maxTokens
+	}
+	if cmd.Flags().Changed("temperature") {
+		req.Temperature = temperature
+	}
+	if cmd.Flags().Changed("top-p") {
+		req.TopP = topP
+	}
+	if topK > 0 {
+		req.TopK = topK
+	}
+	if seed > 0 {
+		req.Seed = seed
+	}
+	if len(stopSequences) > 0 {
+		req.StopSequences = stopSequences
+	}
+	if count > 1 {
+		req.NumberResults = count
+	}
+	if outputFmt != "" {
+		req.OutputFormat = outputFmt
+	}
+
+	// Dry run
+	if dryRun {
+		data, _ := json.MarshalIndent([]interface{}{req}, "", "  ")
+		fmt.Println(string(data))
+		return nil
+	}
+
+	// Submit
+	var s *spinner.Spinner
+	if output.IsTTY() {
+		s = spinner.New(spinner.CharSets[14], 100*time.Millisecond, spinner.WithWriter(os.Stderr))
+		s.Suffix = " Generating text..."
+		s.Start()
+	}
+
+	client := api.NewClient(key, config.GetBaseURL(), flagVerbose)
+	results, err := client.TextInference(context.Background(), req)
+
+	if s != nil {
+		s.Stop()
+	}
+
+	if err != nil {
+		if api.IsAuthError(err) {
+			output.Error("Authentication failed. Run 'runware auth login' to set your API key.")
+			return err
+		}
+		return err
+	}
+
+	if len(results) == 0 {
+		output.Error("No results returned")
+		return fmt.Errorf("empty response from text inference")
+	}
+
+	// JSON/YAML output
+	format := output.ParseFormat(getFormat())
+	if format != output.FormatTable {
+		return output.Print(format, results, nil, nil)
+	}
+
+	// Table: single result without cost — print text directly (pipe-friendly)
+	if len(results) == 1 && !includeCost {
+		fmt.Println(results[0].Text)
+		return nil
+	}
+
+	// Multiple results or cost requested — use table
+	headers := []interface{}{"#", "Text"}
+	if includeCost {
+		headers = append(headers, "Cost")
+	}
+	var rows [][]interface{}
+	for i, r := range results {
+		text := r.Text
+		if len(text) > 100 {
+			text = text[:100] + "..."
+		}
+		row := []interface{}{i + 1, text}
+		if includeCost {
+			row = append(row, fmt.Sprintf("%.6f", r.Cost))
+		}
+		rows = append(rows, row)
+	}
+	return output.Print(format, results, headers, rows)
+}

internal/api/client.go

@@ -18,6 +18,7 @@ type Client interface {
 	ImageInference(ctx context.Context, req *ImageInferenceRequest) ([]ImageInferenceResult, error)
 	VideoInference(ctx context.Context, req *VideoInferenceRequest) ([]VideoInferenceResult, error)
 	AudioInference(ctx context.Context, req *AudioInferenceRequest) ([]AudioInferenceResult, error)
+	TextInference(ctx context.Context, req *TextInferenceRequest) ([]TextInferenceResult, error)
 	GetResponse(ctx context.Context, taskUUID string) ([]json.RawMessage, error)
 	AccountDetails(ctx context.Context) (*AccountResult, error)
 	ModelSearch(ctx context.Context, req *ModelSearchRequest) (*ModelSearchResponse, error)
@@ -245,6 +246,32 @@ func (c *RestClient) AudioInference(ctx context.Context, req *AudioInferenceRequ
 	return results, nil
 }
 
+// TextInference runs a text inference task.
+func (c *RestClient) TextInference(ctx context.Context, req *TextInferenceRequest) ([]TextInferenceResult, error) {
+	req.TaskType = "textInference"
+	if req.TaskUUID == "" {
+		req.TaskUUID = NewUUID()
+	}
+
+	tasks := []interface{}{req}
+
+	resp, err := c.do(ctx, tasks)
+	if err != nil {
+		return nil, err
+	}
+
+	var results []TextInferenceResult
+	for _, raw := range resp.Data {
+		var r TextInferenceResult
+		if err := json.Unmarshal(raw, &r); err != nil {
+			return nil, fmt.Errorf("failed to parse text result: %w", err)
+		}
+		results = append(results, r)
+	}
+
+	return results, nil
+}
+
 // GetResponse polls for async task results.
 func (c *RestClient) GetResponse(ctx context.Context, taskUUID string) ([]json.RawMessage, error) {
 	tasks := []interface{}{

internal/api/types.go

@@ -176,6 +176,47 @@ type AudioInferenceResult struct {
 	Cost      float64 `json:"cost,omitempty"`
 }
 
+// Message represents a single message in a text inference conversation.
+type Message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+// TextInferenceRequest contains fields for the textInference task type.
+type TextInferenceRequest struct {
+	TaskType      string    `json:"taskType"`
+	TaskUUID      string    `json:"taskUUID"`
+	Model         string    `json:"model"`
+	Messages      []Message `json:"messages"`
+	MaxTokens     int       `json:"maxTokens,omitempty"`
+	Temperature   float64   `json:"temperature,omitempty"`
+	TopP          float64   `json:"topP,omitempty"`
+	TopK          int       `json:"topK,omitempty"`
+	Seed          int64     `json:"seed,omitempty"`
+	StopSequences []string  `json:"stopSequences,omitempty"`
+	NumberResults int       `json:"numberResults,omitempty"`
+	SystemPrompt  string    `json:"systemPrompt,omitempty"`
+	OutputFormat  string    `json:"outputFormat,omitempty"`
+	IncludeCost   bool      `json:"includeCost,omitempty"`
+}
+
+// TextInferenceUsage contains token usage statistics.
+type TextInferenceUsage struct {
+	InputTokens  int `json:"inputTokens,omitempty"`
+	OutputTokens int `json:"outputTokens,omitempty"`
+	TotalTokens  int `json:"totalTokens,omitempty"`
+}
+
+// TextInferenceResult is a single text result from the API.
+type TextInferenceResult struct {
+	TaskType     string             `json:"taskType"`
+	TaskUUID     string             `json:"taskUUID"`
+	Text         string             `json:"text"`
+	FinishReason string             `json:"finishReason,omitempty"`
+	Usage        TextInferenceUsage `json:"usage,omitempty"`
+	Cost         float64            `json:"cost,omitempty"`
+}
+
 // ModelSearchRequest contains fields for the modelSearch task type.
 type ModelSearchRequest struct {
 	TaskType     string `json:"taskType"`

internal/api/types_test.go

@@ -652,6 +652,95 @@ func TestModelSearchResponseEmpty(t *testing.T) {
 	}
 }
 
+func TestTextInferenceRequestJSON(t *testing.T) {
+	req := &TextInferenceRequest{
+		TaskType: "textInference",
+		TaskUUID: "test-uuid-1234",
+		Model:    "runware:qwen3-thinking@1",
+		Messages: []Message{
+			{Role: "user", Content: "What is Go?"},
+		},
+		MaxTokens:    500,
+		Temperature:  0.8,
+		SystemPrompt: "You are helpful",
+		IncludeCost:  true,
+	}
+
+	data, err := json.Marshal(req)
+	if err != nil {
+		t.Fatalf("Marshal error: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal(data, &parsed); err != nil {
+		t.Fatalf("Unmarshal error: %v", err)
+	}
+
+	expectedFields := []string{"taskType", "taskUUID", "model", "messages", "maxTokens", "temperature", "systemPrompt", "includeCost"}
+	for _, field := range expectedFields {
+		if _, ok := parsed[field]; !ok {
+			t.Errorf("missing expected field %q in JSON output", field)
+		}
+	}
+
+	// Verify omitempty works for optional fields
+	omittedFields := []string{"topP", "topK", "seed", "stopSequences", "numberResults", "outputFormat"}
+	for _, field := range omittedFields {
+		if _, ok := parsed[field]; ok {
+			t.Errorf("%s should be omitted when zero/empty", field)
+		}
+	}
+
+	// Verify messages structure
+	msgs, ok := parsed["messages"].([]interface{})
+	if !ok {
+		t.Fatal("messages is not an array")
+	}
+	if len(msgs) != 1 {
+		t.Fatalf("expected 1 message, got %d", len(msgs))
+	}
+	msg := msgs[0].(map[string]interface{})
+	if msg["role"] != "user" {
+		t.Errorf("message role = %q, want %q", msg["role"], "user")
+	}
+}
+
+func TestTextInferenceResultJSON(t *testing.T) {
+	jsonData := `{
+		"taskType": "textInference",
+		"taskUUID": "abc-123",
+		"text": "Go is a programming language designed at Google.",
+		"finishReason": "stop",
+		"usage": {
+			"inputTokens": 10,
+			"outputTokens": 25,
+			"totalTokens": 35
+		},
+		"cost": 0.000123
+	}`
+
+	var result TextInferenceResult
+	if err := json.Unmarshal([]byte(jsonData), &result); err != nil {
+		t.Fatalf("Unmarshal error: %v", err)
+	}
+
+	if result.TaskType != "textInference" {
+		t.Errorf("taskType = %q, want %q", result.TaskType, "textInference")
+	}
+	if result.Text == "" {
+		t.Error("text is empty")
+	}
+	if result.FinishReason != "stop" {
+		t.Errorf("finishReason = %q, want %q", result.FinishReason, "stop")
+	}
+	if result.Usage.TotalTokens != 35 {
+		t.Errorf("totalTokens = %d, want %d", result.Usage.TotalTokens, 35)
+	}
+	if result.Cost != 0.000123 {
+		t.Errorf("cost = %f, want %f", result.Cost, 0.000123)
+	}
+}
+
 func TestNewUUID(t *testing.T) {
 	id1 := NewUUID()
 	id2 := NewUUID()