AI Engine

# Add the AI component
npx gencow@latest add AI

import { generateText, streamText } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();

function isStreamingUnavailable(error: unknown): boolean {
    const message = error instanceof Error ? error.message : String(error);
    return /stream|unsupported|disabled/i.test(message);
}

type ChatMessage = { role: "user"; content: string };

export async function answerWithOptionalStreaming(messages: ChatMessage[], options = { preferStreaming: false }) {
    if (options.preferStreaming) {
        try {
            const stream = streamText({
                model: gencow.languageModel("gpt-5.4-mini"),
                messages,
            });

            return { kind: "stream" as const, stream: stream.textStream };
        } catch (error) {
            // Fall back when the deployed platform has streaming disabled.
            // Do not log prompts, tokens, provider keys, or private file URLs here.
            if (!isStreamingUnavailable(error)) {
                throw error;
            }
        }
    }

    const result = await generateText({
        model: gencow.languageModel("gpt-5.4-mini"),
        messages,
    });

    return { kind: "text" as const, text: result.text };
}

import { embed, generateImage, generateText, rerank } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();

import { v } from "@gencow/core";
import { generateText } from "ai";
import { procedure } from "./runtime";
import { createGencowAI } 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 gencow = createGencowAI();
        const result = await generateText({
            model: gencow.languageModel("gpt-5.4-mini"),
            system: "You are a concise support assistant.",
            messages: input.messages,
        });

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

import { generateText } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();

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

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

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

// Compatibility with older generated examples
await generateText({
    model: gencow.languageModel("gpt-5-mini"),
    messages: [{ role: "user", content: "안녕?" }],
});

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

const analysisSchema = z.object({
    sentiment: z.enum(["positive", "negative", "neutral"]),
    score: z.number().min(0).max(1),
    keywords: z.array(z.string()),
    summary: z.string(),
});

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

        const gencow = createGencowAI();
        const { object } = await generateObject({
            model: gencow.languageModel("gpt-5.4-mini"),
            system: "Analyze the text and extract structured data.",
            schema: analysisSchema,
            prompt: input.text,
        });

        return object;
    });

import { generateImage } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();
const result = await generateImage({
    model: gencow.imageModel("gpt-image-2"),
    prompt: "A clean product shot of a stainless steel water bottle",
});

const image = result.images[0];
// image.base64, image.mediaType — standard AI SDK GenerateImageResult shape

import { embed } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();
const { embedding } = await embed({
    model: gencow.embeddingModel("text-embedding-3-small"),
    value: "Hello, world!",
});
// number[]; text-embedding-3-small currently returns 1536 dimensions

import { rerank } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();
const result = await rerank({
    model: gencow.rerankingModel("Cohere-rerank-v4.0-fast"),
    query: "refund policy",
    documents: [
        "Refunds are available within 30 days.",
        "Invoices are emailed after payment.",
    ],
    topN: 1,
});

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

import { ai } from "./ai";

// Highest-quality reasoning/coding path (Startup and Enterprise)
await ai.chat({
    model: "gpt-5.4",
    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-5-mini",
    messages: [{ role: "user", content: "안녕?" }],
});

import { ai } from "./ai";

const result = await ai.chat({
    model: "gpt-5.4-mini",
    messages: [
        {
            role: "user",
            content: [
                { type: "text", text: "Extract the visible text as Markdown." },
                {
                    type: "image",
                    image: receiptBase64,
                    mediaType: "image/png",
                    detail: "high",
                },
            ],
        },
    ],
});

console.log(result.text);

import { ai } from "./ai";

const extracted = await ai.vision.extractText({
    image: receiptBase64,
    mediaType: "image/png",
    output: "markdown",
});

console.log(extracted.markdown ?? extracted.text);

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

import { ai } from "./ai";

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,
};

import { ai } from "./ai";

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

import { ai } from "./ai";

const ranked = await ai.rerank({
    query: "refund policy for startup plan",
    documents: candidates.map((candidate) => ({
        id: candidate.id,
        text: candidate.text,
    })),
    topK: 5,
    providerPreference: "auto",
});

ranked.provider       // "azure_cohere" or "openai"
ranked.model          // "Cohere-rerank-v4.0-fast" or "gpt-5.4-mini"
ranked.fallbackUsed   // true when GPT fallback was used
ranked.results        // [{ index, id?, relevanceScore }]

import { ai } from "./ai";

const job = await ai.speech.transcribe({
    storageId: uploadedAudio.storageId,
    model: "gpt-4o-mini-transcribe",
    language: "ko",
    responseFormat: "json",
    idempotencyKey: requestId,
});

const transcriptJob = await ai.speech.waitForTranscript(job.id, {
    timeoutMs: 10 * 60 * 1000,
    pollIntervalMs: 2000,
});

return {
    status: transcriptJob.status,
    transcriptStorageId: transcriptJob.transcriptStorageId,
    result: transcriptJob.result,
};

import { ai } from "./ai";

const narrationText = getNarrationTextFromYourApp();

const audio = await ai.speech.synthesize({
    input: narrationText,
    model: "gpt-4o-mini-tts",
    voice: "alloy",
    format: "mp3",
    includeReadGrant: true,
});

return {
    storageId: audio.storageId,
    contentType: audio.contentType,
    bytes: audio.bytes,
    downloadUrl: audio.downloadUrl,
};

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

result.text                        // AI response text
result.usage.totalTokens           // Token usage
result.creditsCharged              // Informational facade field; gateway billing is authoritative
result.model                       // Model name used

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

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

OPENAI_API_KEY=sk-...

baseCredits =
  inputTokens  * inputCrPerToken +
  outputTokens * outputCrPerToken

creditsCharged = baseCredits * plan.serviceMarkup

base = 7.5 + 45 = 52.5 credits
charged = 52.5 * 0.8 = 42 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 { generateText } from "ai";
import { createGencowAI } from "./ai";

const gencow = createGencowAI();
const result = await generateText({
    model: gencow.languageModel("gpt-5.4-mini"),
    messages: [{ role: "user", content: "Hello" }],
});
console.log(result.text);

Need AI?
    |
    |-- Chat / text response       -> gencow add AI -> createGencowAI() + generateText()
    |-- Typed JSON extraction      -> gencow add AI -> createGencowAI() + generateObject()
    |-- Image generation           -> gencow add AI -> createGencowAI() + generateImage()
    |-- Reranking candidates       -> gencow add AI -> createGencowAI() + rerank()
    |-- Speech-to-text             -> gencow add AI -> ai.speech.transcribe() + waitForTranscript()
    |-- Text-to-speech             -> gencow add AI -> ai.speech.synthesize()
    |-- 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 -> createGencowAI() + 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