AI SDK

[WilliamAvHolmberg]

perhaps take inspiration from AI sdk and just remove all NOISE from the sdk, GenerateObject and similar

[WilliamAvHolmberg]

Feature Request: Add generateObject support to Frontend and .NET Backend SDKs

Summary

Add a generateObject function (similar to Vercel AI SDK's implementation) to both frontend and .NET backend SDKs to enable structured LLM outputs with dynamic schema validation - where the Zod schema is sent from frontend to backend, eliminating the need to hardcode C# models.

Motivation

Currently, getting structured data from LLMs requires manual prompt engineering and JSON parsing with error handling. A generateObject utility would:

• Reduce boilerplate: No need to manually parse and validate JSON responses
• Improve reliability: Automatic retry logic when LLM returns invalid schema
• Enable rapid prototyping: Developers can quickly add AI features without extensive setup
• Maintain type safety: TypeScript types inferred directly from Zod schemas
• 🔥 Dynamic schemas: Frontend defines the schema once; backend receives and validates against it automatically

The Key Innovation: No Backend Model Definitions Required

Frontend defines everything:

// Frontend - this is the ONLY place you define the structure
const { object, isLoading } = useGenerateObject({
  schema: z.object({
    translations: z.array(
      z.object({
        language: z.string().describe('The target language name'),
        languageCode: z.string().describe('ISO 639-1 language code (e.g., "en", "no")'),
        translatedText: z.string().describe('The translated text'),
        context: z.string().optional().describe('Optional context or notes about the translation')
      })
    )
  }),
  prompt: `You are an expert translator. Translate 'Betalkort' into the following languages: English, Norwegian, Finnish`
});

// object.translations is fully typed!

Backend automatically handles any schema:

// Backend - NO need to define Translation or TranslationOutput classes!
[HttpPost("generate-object")]
public async Task<IActionResult> GenerateObject([FromBody] GenerateObjectRequest request)
{
    // request.schema contains the Zod schema as JSON Schema
    // request.prompt contains the prompt
    
    var result = await client.GenerateObjectAsync(
        schema: request.Schema, // Dynamic JSON Schema from Zod
        prompt: request.Prompt,
        model: "gpt-4"
    );
    
    return Ok(result.Object); // Returns validated JSON matching the schema
}

How It Works

1. Frontend: Zod schema is automatically converted to JSON Schema
2. Transport: JSON Schema + prompt sent to backend
3. Backend: Uses JSON Schema to instruct LLM and validate response
4. Response: Validated JSON returned to frontend
5. Frontend: Zod parses and types the response

Proposed API

Frontend Hook (TypeScript)

useGenerateObject<T extends z.ZodType>({
  schema: T,
  prompt: string,
  model?: string,
  temperature?: number,
  endpoint?: string, // Backend endpoint to call
  // ... other LLM params
}): {
  object: z.infer<T> | null,
  isLoading: boolean,
  error: Error | null,
  regenerate: () => void
}

.NET Backend Method

public class GenerateObjectRequest
{
    public JsonSchema Schema { get; set; } // JSON Schema from Zod
    public string Prompt { get; set; }
    public string Model { get; set; }
    public double? Temperature { get; set; }
}

public class GenerateObjectResult
{
    public JsonElement Object { get; set; } // Dynamic JSON
    public TokenUsage Usage { get; set; }
    public string FinishReason { get; set; }
}

Task<GenerateObjectResult> GenerateObjectAsync(
    JsonSchema schema,
    string prompt,
    string model,
    GenerateObjectOptions? options = null,
    CancellationToken cancellationToken = default
)

Benefits

1. 🎯 Single source of truth: Schema defined once in frontend
2. ⚡ Rapid iteration: Add new AI features without backend changes
3. 🔒 Type safety: Full TypeScript IntelliSense on frontend
4. ♻️ Reusable backend: One endpoint handles any structured generation
5. 🚀 Faster development: No need to sync models between frontend/backend
6. ✅ Automatic validation: Both frontend and backend validate against same schema

Real-World Impact

Before (Current approach):

// Backend - must define and maintain
public class Translation { ... }
public class TranslationOutput { ... }
public class ProductDescription { ... }
public class SentimentAnalysis { ... }
// ...dozens more models for each AI feature

After (With generateObject):

// Backend - one generic endpoint for ALL structured generation
[HttpPost("generate-object")]
public async Task<IActionResult> GenerateObject([FromBody] GenerateObjectRequest request)
{
    return Ok(await client.GenerateObjectAsync(request.Schema, request.Prompt, request.Model));
}

Alternative Solutions Considered

• Manual JSON parsing + Zod validation (verbose, error-prone)
• Hardcoded C# models (requires backend changes for every new feature)
• Function calling / tools (more complex, not ideal for simple structured outputs)
• JSON mode (requires manual validation, no schema enforcement)

Implementation Notes

The .NET SDK would need to:

• Accept JSON Schema as input
• Convert JSON Schema to LLM-compatible format (function calling or structured output)
• Validate LLM response against JSON Schema
• Return validated JSON

Frontend SDK would need to:

• Convert Zod schema to JSON Schema (zod-to-json-schema library)
• Send schema + prompt to backend
• Parse and validate response with original Zod schema

References

Similar implementations:

• [Vercel AI SDK - generateObject](https://sdk.vercel.ai/docs/reference/ai-sdk-core/generate-object)
• [Instructor](https://github.com/jxnl/instructor) (Python)
• [zod-to-json-schema](https://github.com/StefanTerdell/zod-to-json-schema)

---