totalum-sdk 0.1.0-dev.4 → 0.1.0-dev.5

package/dist/_types/ops.d-BIgDkhpR.d.ts

@@ -0,0 +1,117 @@
+import { Z as ZodObject, c as ZodOptional, e as ZodArray, t as ZodISODateTime, u as $catchall, k as ZodNumber, d as ZodString, f as ZodEnum, m as $strip, q as ZodLiteral, j as ZodBoolean, o as output, v as ZodNullable, l as ZodInt } from './errors.d-ZrZKjL3U.js';
+import { Z as ZodCoercedNumber } from './coerce.d-C1KWvgPp.js';
+
+declare const SiteMetric: ZodEnum<{
+    bytes: "bytes";
+    errors: "errors";
+    page_views: "page_views";
+    hits: "hits";
+    uniques: "uniques";
+    ttfb_p50: "ttfb_p50";
+    ttfb_p95: "ttfb_p95";
+}>;
+type SiteMetric = output<typeof SiteMetric>;
+declare const SiteDimension: ZodEnum<{
+    hostname: "hostname";
+    browser: "browser";
+    path: "path";
+    status: "status";
+    country: "country";
+    device: "device";
+    os: "os";
+    referrer: "referrer";
+}>;
+type SiteDimension = output<typeof SiteDimension>;
+/** `series` for a time series, `top` when a `dimension` is asked; every count is `SUM(_sample_interval)`. */
+declare const SiteAnalyticsOutput: ZodObject<{
+    series: ZodOptional<ZodArray<ZodObject<{
+        t: ZodISODateTime;
+    }, $catchall<ZodNumber>>>>;
+    top: ZodOptional<ZodArray<ZodObject<{
+        key: ZodString;
+        share: ZodNumber;
+    }, $catchall<ZodNumber>>>>;
+    window: ZodObject<{
+        from: ZodISODateTime;
+        to: ZodISODateTime;
+        granularity: ZodEnum<{
+            hour: "hour";
+            day: "day";
+            minute: "minute";
+        }>;
+    }, $strip>;
+    source: ZodLiteral<"wae">;
+    approximate: ZodObject<{
+        uniques: ZodBoolean;
+    }, $strip>;
+    cachedAt: ZodISODateTime;
+}, $strip>;
+type SiteAnalyticsOutput = output<typeof SiteAnalyticsOutput>;
+/** `POST /projects/:id/logs/query` (PGM) = `GET /v1/logs` query (SDK-API). `env`: dev = preview, live = published. */
+declare const LogsQueryInput: ZodObject<{
+    requestId: ZodOptional<ZodString>;
+    limit: ZodOptional<ZodCoercedNumber<unknown>>;
+    source: ZodOptional<ZodEnum<{
+        live: "live";
+        auto: "auto";
+        buffer: "buffer";
+    }>>;
+    env: ZodOptional<ZodEnum<{
+        dev: "dev";
+        live: "live";
+    }>>;
+    caller: ZodOptional<ZodLiteral<"agent">>;
+    runId: ZodOptional<ZodString>;
+    level: ZodOptional<ZodEnum<{
+        error: "error";
+        log: "log";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+    q: ZodOptional<ZodString>;
+    status: ZodOptional<ZodString>;
+    path: ZodOptional<ZodString>;
+    from: ZodOptional<ZodISODateTime>;
+    to: ZodOptional<ZodISODateTime>;
+}, $strip>;
+type LogsQueryInput = output<typeof LogsQueryInput>;
+declare const LogsPage: ZodObject<{
+    items: ZodArray<ZodObject<{
+        ts: ZodISODateTime;
+        level: ZodEnum<{
+            error: "error";
+            log: "log";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>;
+        message: ZodString;
+        requestId: ZodNullable<ZodString>;
+        method: ZodNullable<ZodString>;
+        path: ZodNullable<ZodString>;
+        status: ZodNullable<ZodInt>;
+        cpuMs: ZodNullable<ZodNumber>;
+        wallMs: ZodNullable<ZodNumber>;
+        outcome: ZodString;
+        exception: ZodOptional<ZodObject<{
+            name: ZodString;
+            message: ZodString;
+            stack: ZodOptional<ZodString>;
+        }, $strip>>;
+    }, $strip>>;
+    window: ZodObject<{
+        from: ZodISODateTime;
+        to: ZodISODateTime;
+        source: ZodEnum<{
+            live: "live";
+            buffer: "buffer";
+        }>;
+    }, $strip>;
+    nextCursor: ZodNullable<ZodString>;
+    sampled: ZodBoolean;
+    hint: ZodOptional<ZodString>;
+}, $strip>;
+type LogsPage = output<typeof LogsPage>;
+
+export { LogsPage as L, SiteAnalyticsOutput as S, SiteDimension as a, SiteMetric as b, LogsQueryInput as c };

package/dist/ai/index.d.ts

@@ -0,0 +1,424 @@
+import { Z as ZodObject, c as ZodOptional, d as ZodString, e as ZodArray, f as ZodEnum, g as ZodUnknown, $ as $loose, h as ZodRecord, j as ZodBoolean, k as ZodNumber, l as ZodInt, m as $strip, o as output, n as ZodUnion, p as ZodURL, q as ZodLiteral, T as TotalumClientOptions } from '../_types/errors.d-ZrZKjL3U.js';
+export { a as TotalumError, i as isTotalumError } from '../_types/errors.d-ZrZKjL3U.js';
+import { I as IntegrationUsage } from '../_types/billing.d-Cj9gNbAW.js';
+import { SpeakInput, StoredMedia, TranscribeInput } from '../index.js';
+import '../_types/coerce.d-C1KWvgPp.js';
+
+/** `POST /v1/ai/chat` (integration `ai_text`); `stream:true` answers SSE ending with `AiStreamCreditsChunk`. */
+declare const AiChatInput: ZodObject<{
+    model: ZodOptional<ZodString>;
+    messages: ZodArray<ZodObject<{
+        role: ZodEnum<{
+            user: "user";
+            system: "system";
+            assistant: "assistant";
+            tool: "tool";
+            developer: "developer";
+        }>;
+        content: ZodUnknown;
+    }, $loose>>;
+    tools: ZodOptional<ZodArray<ZodRecord<ZodString, ZodUnknown>>>;
+    toolChoice: ZodOptional<ZodUnknown>;
+    parallelToolCalls: ZodOptional<ZodBoolean>;
+    responseFormat: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+    temperature: ZodOptional<ZodNumber>;
+    maxTokens: ZodOptional<ZodInt>;
+    reasoning: ZodOptional<ZodObject<{
+        effort: ZodString;
+    }, $strip>>;
+    serverTools: ZodOptional<ZodArray<ZodEnum<{
+        web_search: "web_search";
+        image_generation: "image_generation";
+        web_fetch: "web_fetch";
+        datetime: "datetime";
+    }>>>;
+    maxToolCalls: ZodOptional<ZodInt>;
+    stream: ZodOptional<ZodBoolean>;
+    cache: ZodOptional<ZodObject<{
+        ttlSec: ZodInt;
+    }, $strip>>;
+    zdr: ZodOptional<ZodBoolean>;
+    fastMode: ZodOptional<ZodBoolean>;
+    user: ZodOptional<ZodString>;
+}, $strip>;
+type AiChatInput = output<typeof AiChatInput>;
+/** `POST /v1/ai/embed` (integration `ai_embed`): ≤ 256 inputs. */
+declare const AiEmbedInput: ZodObject<{
+    model: ZodOptional<ZodString>;
+    input: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
+}, $strip>;
+type AiEmbedInput = output<typeof AiEmbedInput>;
+declare const AiEmbedOutput: ZodObject<{
+    embeddings: ZodArray<ZodArray<ZodNumber>>;
+    usage: ZodObject<{
+        credits: ZodNumber;
+        vendor: ZodOptional<ZodString>;
+        units: ZodOptional<ZodNumber>;
+        vendorCostUsd: ZodOptional<ZodNumber>;
+    }, $strip>;
+}, $strip>;
+type AiEmbedOutput = output<typeof AiEmbedOutput>;
+/** `POST /v1/ai/image` (integration `ai_image`): stored in R2 through the storage gate. */
+declare const AiImageInput: ZodObject<{
+    prompt: ZodString;
+    model: ZodOptional<ZodString>;
+    aspectRatio: ZodOptional<ZodString>;
+    resolution: ZodOptional<ZodEnum<{
+        512: "512";
+        "1K": "1K";
+        "2K": "2K";
+        "4K": "4K";
+    }>>;
+    quality: ZodOptional<ZodString>;
+    outputFormat: ZodOptional<ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+        webp: "webp";
+    }>>;
+    background: ZodOptional<ZodString>;
+    n: ZodOptional<ZodInt>;
+    references: ZodOptional<ZodArray<ZodString>>;
+    fileName: ZodOptional<ZodString>;
+    store: ZodOptional<ZodBoolean>;
+}, $strip>;
+type AiImageInput = output<typeof AiImageInput>;
+/** `POST /v1/ai/image/edit` (v1 `image-edit` parity: 1–16 source images). */
+declare const AiImageEditInput: ZodObject<{
+    prompt: ZodString;
+    images: ZodArray<ZodURL>;
+    mask: ZodOptional<ZodString>;
+    fileName: ZodOptional<ZodString>;
+    size: ZodOptional<ZodString>;
+    quality: ZodOptional<ZodString>;
+    outputFormat: ZodOptional<ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+        webp: "webp";
+    }>>;
+    background: ZodOptional<ZodString>;
+    inputFidelity: ZodOptional<ZodString>;
+}, $strip>;
+type AiImageEditInput = output<typeof AiImageEditInput>;
+/** `images[]` in R2; the v1 compat keys `fileName`/`imageUrl` describe the first image. */
+declare const AiImageOutput: ZodObject<{
+    images: ZodArray<ZodObject<{
+        key: ZodString;
+        url: ZodURL;
+        mediaType: ZodString;
+        width: ZodOptional<ZodInt>;
+        height: ZodOptional<ZodInt>;
+    }, $strip>>;
+    usage: ZodObject<{
+        credits: ZodNumber;
+        vendor: ZodOptional<ZodString>;
+        units: ZodOptional<ZodNumber>;
+        vendorCostUsd: ZodOptional<ZodNumber>;
+    }, $strip>;
+    fileName: ZodOptional<ZodString>;
+    imageUrl: ZodOptional<ZodURL>;
+}, $strip>;
+type AiImageOutput = output<typeof AiImageOutput>;
+/** `POST /v1/ai/video` (integration `ai_video`, every plan incl. Free — A10.1): `202 AiVideoCreated`. */
+declare const AiVideoInput: ZodObject<{
+    prompt: ZodString;
+    model: ZodOptional<ZodString>;
+    durationSec: ZodInt;
+    resolution: ZodOptional<ZodString>;
+    aspectRatio: ZodOptional<ZodString>;
+    firstFrame: ZodOptional<ZodString>;
+    lastFrame: ZodOptional<ZodString>;
+    references: ZodOptional<ZodArray<ZodString>>;
+    generateAudio: ZodOptional<ZodBoolean>;
+    seed: ZodOptional<ZodInt>;
+    webhook: ZodOptional<ZodBoolean>;
+}, $strip>;
+type AiVideoInput = output<typeof AiVideoInput>;
+declare const AiVideoCreated: ZodObject<{
+    jobId: ZodString;
+    status: ZodLiteral<"queued">;
+    estimatedCredits: ZodNumber;
+}, $strip>;
+type AiVideoCreated = output<typeof AiVideoCreated>;
+/** `GET /v1/ai/video/:jobId`; `failed`/`expired` settle to 0. */
+declare const AiVideoJob: ZodObject<{
+    jobId: ZodString;
+    status: ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        expired: "expired";
+    }>;
+    progress: ZodOptional<ZodNumber>;
+    video: ZodOptional<ZodObject<{
+        key: ZodString;
+        url: ZodURL;
+    }, $strip>>;
+    usage: ZodOptional<ZodObject<{
+        credits: ZodNumber;
+        vendor: ZodOptional<ZodString>;
+        units: ZodOptional<ZodNumber>;
+        vendorCostUsd: ZodOptional<ZodNumber>;
+    }, $strip>>;
+    error: ZodOptional<ZodObject<{
+        code: ZodString;
+        message: ZodString;
+    }, $strip>>;
+}, $strip>;
+type AiVideoJob = output<typeof AiVideoJob>;
+/** `POST /v1/ai/vision/describe`. */
+declare const AiVisionDescribeInput: ZodObject<{
+    image: ZodString;
+    prompt: ZodOptional<ZodString>;
+    model: ZodOptional<ZodString>;
+}, $strip>;
+type AiVisionDescribeInput = output<typeof AiVisionDescribeInput>;
+declare const AiTextOutput: ZodObject<{
+    text: ZodString;
+    usage: ZodObject<{
+        credits: ZodNumber;
+        vendor: ZodOptional<ZodString>;
+        units: ZodOptional<ZodNumber>;
+        vendorCostUsd: ZodOptional<ZodNumber>;
+    }, $strip>;
+}, $strip>;
+type AiTextOutput = output<typeof AiTextOutput>;
+/** `GET /v1/ai/models` (cached 1 h). */
+declare const AiModelsOutput: ZodObject<{
+    aliases: ZodObject<{
+        cheap: ZodString;
+        normal: ZodString;
+        best: ZodString;
+    }, $strip>;
+    models: ZodArray<ZodObject<{
+        slug: ZodString;
+        name: ZodString;
+        inputModalities: ZodArray<ZodString>;
+        pricing: ZodRecord<ZodString, ZodUnknown>;
+        contextLength: ZodInt;
+    }, $strip>>;
+    denylist: ZodOptional<ZodArray<ZodString>>;
+}, $strip>;
+type AiModelsOutput = output<typeof AiModelsOutput>;
+
+interface TotalumAiOptions extends TotalumClientOptions {
+    /** The exact-OpenRouter gateway `gatewayConfig()` returns; default `TOTALUM_AI_BASE_URL`, else `https://ai.totalum.app/api/v1`. */
+    aiBaseUrl?: string;
+}
+interface ChatUsage {
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    credits: number;
+}
+interface ToolCall {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** `ai.chat()` (plan 05 §6.1): the first choice read out, the raw completion kept. */
+interface ChatResult {
+    id: string;
+    model: string;
+    text: string;
+    toolCalls: ToolCall[];
+    finishReason: string | null;
+    usage: ChatUsage;
+    raw: unknown;
+}
+/** `ai.chat.stream()`: the OpenAI-format SSE (`raw`), its text deltas, and the result once it ends. */
+interface ChatStream {
+    readonly raw: ReadableStream<Uint8Array>;
+    text(): AsyncIterable<string>;
+    result(): Promise<ChatResult>;
+}
+/**
+ * `totalum.ai` (plan 05 §6.1, plan 04 §5.1) over SDK-API `/v1/ai/*` (scope `ai`): aliases `cheap|normal|best` or any
+ * OpenRouter slug, every call priced `usage.cost × 28` and returned with its credits. No `ai.agent()` (A5.27) — the
+ * agent loop is the template's `src/agents/` on the Vercel AI SDK, pointed at `gatewayConfig()`.
+ */
+declare function totalumAi(options?: TotalumAiOptions): {
+    chat: ((req: Omit<AiChatInput, "stream">) => Promise<ChatResult>) & {
+        /**
+         * The same request streamed: `raw` is the OpenAI-format SSE (return it from a route), `text()` its deltas,
+         * `result()` the final result with its credits.
+         */
+        stream: (req: Omit<AiChatInput, "stream">) => Promise<ChatStream>;
+    };
+    generateObject: (req: {
+        schema: Record<string, unknown>;
+        prompt?: string;
+        messages?: AiChatInput["messages"];
+        model?: string;
+        healing?: boolean;
+    }) => Promise<{
+        object: unknown;
+        usage: IntegrationUsage;
+    }>;
+    /** Sugar over `generateObject`: one of `options`, chosen by the model. */
+    classify(req: {
+        input: string;
+        options: readonly string[];
+        model?: string;
+        instructions?: string;
+    }): Promise<{
+        label: string;
+    }>;
+    /** Embedding vectors for one or more texts. */
+    embed: (req: AiEmbedInput) => Promise<{
+        embeddings: number[][];
+        usage: {
+            credits: number;
+            vendor?: string | undefined;
+            units?: number | undefined;
+            vendorCostUsd?: number | undefined;
+        };
+    }>;
+    image: {
+        /** Images from a prompt; `store: true` keeps them as project files. */
+        generate: (req: AiImageInput) => Promise<{
+            images: {
+                key: string;
+                url: string;
+                mediaType: string;
+                width?: number | undefined;
+                height?: number | undefined;
+            }[];
+            usage: {
+                credits: number;
+                vendor?: string | undefined;
+                units?: number | undefined;
+                vendorCostUsd?: number | undefined;
+            };
+            fileName?: string | undefined;
+            imageUrl?: string | undefined;
+        }>;
+        /** An image edited by a prompt. */
+        edit: (req: AiImageEditInput) => Promise<{
+            images: {
+                key: string;
+                url: string;
+                mediaType: string;
+                width?: number | undefined;
+                height?: number | undefined;
+            }[];
+            usage: {
+                credits: number;
+                vendor?: string | undefined;
+                units?: number | undefined;
+                vendorCostUsd?: number | undefined;
+            };
+            fileName?: string | undefined;
+            imageUrl?: string | undefined;
+        }>;
+    };
+    video: {
+        /** `202`: the job and the credits reserved for it; poll `get(jobId)` (the clip is stored when it completes). */
+        generate: (req: AiVideoInput) => Promise<{
+            jobId: string;
+            status: "queued";
+            estimatedCredits: number;
+        }>;
+        /** The video job: `status`, and the stored clip once completed. */
+        get: (jobId: string) => Promise<{
+            jobId: string;
+            status: "queued" | "running" | "completed" | "failed" | "cancelled" | "expired";
+            progress?: number | undefined;
+            video?: {
+                key: string;
+                url: string;
+            } | undefined;
+            usage?: {
+                credits: number;
+                vendor?: string | undefined;
+                units?: number | undefined;
+                vendorCostUsd?: number | undefined;
+            } | undefined;
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+        }>;
+        /**
+         * ⚠ NODE-ONLY: polls `get(jobId)` until the job leaves `queued`/`running` (default every 5 s, at most 10 min).
+         * In a Worker it throws `NODE_ONLY` — store the `jobId` and read `get(jobId)` later instead.
+         */
+        wait(jobId: string, opts?: {
+            intervalMs?: number;
+            timeoutMs?: number;
+        }): Promise<AiVideoJob>;
+    };
+    vision: {
+        /** A text description of an image (URL, data URL or project file key). */
+        describe: (req: AiVisionDescribeInput) => Promise<{
+            text: string;
+            usage: {
+                credits: number;
+                vendor?: string | undefined;
+                units?: number | undefined;
+                vendorCostUsd?: number | undefined;
+            };
+        }>;
+    };
+    speech: {
+        /** Same as `speech.synthesize`. */
+        speak: (input: SpeakInput) => Promise<StoredMedia | {
+            audio: ArrayBuffer;
+            contentType: string;
+            credits: number;
+        }>;
+        /** Same as `speech.transcribe`. */
+        transcribe: (input: TranscribeInput) => Promise<{
+            text: string;
+            durationSec: number;
+            usage: {
+                credits: number;
+                vendor?: string | undefined;
+                units?: number | undefined;
+                vendorCostUsd?: number | undefined;
+            };
+            language?: string | undefined;
+            segments?: {
+                start: number;
+                end: number;
+                text: string;
+            }[] | undefined;
+            words?: {
+                word: string;
+                start: number;
+                end: number;
+            }[] | undefined;
+        }>;
+    };
+    models: {
+        /** The model aliases and the models a project may call, with their prices. */
+        list: () => Promise<{
+            aliases: {
+                cheap: string;
+                normal: string;
+                best: string;
+            };
+            models: {
+                slug: string;
+                name: string;
+                inputModalities: string[];
+                pricing: Record<string, unknown>;
+                contextLength: number;
+            }[];
+            denylist?: string[] | undefined;
+        }>;
+    };
+    /** The exact OpenRouter API for any OpenRouter/OpenAI client (A6.19): `new OpenAI(ai.gatewayConfig())`. Server-side only. */
+    gatewayConfig: () => {
+        baseURL: string;
+        apiKey: string;
+    };
+};
+type TotalumAi = ReturnType<typeof totalumAi>;
+
+export { AiChatInput, AiEmbedInput, AiEmbedOutput, AiImageEditInput, AiImageInput, AiImageOutput, AiModelsOutput, AiTextOutput, AiVideoCreated, AiVideoInput, AiVideoJob, AiVisionDescribeInput, TotalumClientOptions, totalumAi };
+export type { ChatResult, ChatStream, ChatUsage, TotalumAi, TotalumAiOptions };