AI Engine

import { ai } from "./ai";

# Add the AI component (installs ai + @ai-sdk/openai)
npx gencow@latest add AI

import { ai } from "./ai";

import { v } from "@gencow/core";
import { procedure } from "./runtime";
import { ai } from "./ai";

export const chat = procedure.mutation
    .name("chat.send")
    .input(v.object({
        messages: v.array(v.object({
            role: v.string(),
            content: v.string(),
        })),
    }))
    .handler(async ({ context: ctx, input }) => {
        ctx.auth.requireAuth();

        const result = await ai.chat({
            system: "You are a concise support assistant.",
            messages: input.messages,
            model: "gpt-5.4-mini",
        });

        return {
            role: "assistant",
            content: result.text,
            usage: result.usage,
            creditsCharged: result.creditsCharged,
        };
    });

const icon = await ai.image.generate({
    prompt: "A clean app icon for a project management product",
    model: "gpt-image-2",
    size: "1024x1024",
    quality: "low",
    format: "png",
});

return {
    base64: icon.images[0].base64,
    mimeType: icon.images[0].mimeType,
    creditsCharged: icon.creditsCharged,
};

// Highest-quality reasoning/coding path
await ai.chat({
    model: "gpt-5.5",
    messages: [{ role: "user", content: "Review this architecture..." }],
});

// Strong default for most production chat, coding, and agent steps
await ai.chat({
    model: "gpt-5.4-mini",
    messages: [{ role: "user", content: "Draft the reply." }],
});

// High-volume classification/extraction
await ai.chat({
    model: "gpt-5.4-nano",
    messages: [{ role: "user", content: "Classify this ticket." }],
});

// Compatibility with older generated examples
await ai.chat({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: "안녕?" }],
});

import { v } from "@gencow/core";
import { procedure } from "./runtime";
import { z } from "zod";
import { ai } from "./ai";

export const analyze = procedure.mutation
    .name("tasks.analyze")
    .input(v.object({ text: v.string() }))
    .handler(async ({ context: ctx, input }) => {
        ctx.auth.requireAuth();

        const { object } = await ai.generateObject({
            model: "gpt-5.4-mini",
            system: "Analyze the text and extract structured data.",
            schema: z.object({
                sentiment: z.enum(["positive", "negative", "neutral"]),
                score: z.number().min(0).max(1),
                keywords: z.array(z.string()),
                summary: z.string(),
            }),
            prompt: input.text,
        });

        return object;
    });

const result = await ai.chat({ messages: [{ role: "user", content: "Hi" }] });

result.text              // AI response text
result.usage.totalTokens // Token usage
result.creditsCharged    // Service credits charged in cloud; 0 in local mode
result.model             // Model name used

// Wrong: result is an object
console.log(result);

// Correct
console.log(result.text);

const embedding = await ai.embed("Hello, world!");
// number[]; text-embedding-3-small currently returns 1536 dimensions

OPENAI_API_KEY=sk-...

baseCredits =
  inputTokens  * inputCrPerToken +
  outputTokens * outputCrPerToken

creditsCharged = baseCredits * plan.serviceMarkup

base = 7.5 + 45 = 52.5 credits
charged = 52.5 * 1.0 = 52.5 credits

// Wrong: provider SDK/key management bypasses Gencow
import OpenAI from "openai";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
await openai.chat.completions.create({
    model: "gpt-5.4-mini",
    messages: [{ role: "user", content: "Hello" }],
});

// Correct: generated Gencow AI helper
import { ai } from "./ai";
const result = await ai.chat({
    model: "gpt-5.4-mini",
    messages: [{ role: "user", content: "Hello" }],
});
console.log(result.text);

Need AI?
    |
    |-- Chat / text response       -> gencow add AI -> ai.chat()
    |-- Typed JSON extraction      -> gencow add AI -> ai.generateObject({ schema })
    |-- Image generation           -> gencow add AI -> ai.image.generate()
    |-- Document search / RAG      -> gencow add RAG -> rag.retrieve() / ctx.search()
    |-- Agent memory               -> gencow add Memory -> memory.buildContext()
    |-- Safety filtering           -> gencow add Guardrails -> guardrails.validateInput()
    `-- Vector embedding           -> gencow add AI -> ai.embed()

# Do not install provider SDKs directly for app AI calls
npm install openai
npm install @anthropic-ai/sdk
npm install @google/generative-ai

# Use Gencow components
npx gencow@latest add AI
npx gencow@latest add RAG
npx gencow@latest add Memory