@builder.io/ai-utils 0.81.3 → 0.83.0

package/src/embeddings.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export declare const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export declare const BUILDER_EMBEDDING_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+export declare const BuilderEmbeddingImageSchema: z.ZodObject<{
+    mimeType: z.ZodEnum<{
+        "image/gif": "image/gif";
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+        "image/webp": "image/webp";
+    }>;
+    data: z.ZodString;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingInputSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        mimeType: z.ZodEnum<{
+            "image/gif": "image/gif";
+            "image/jpeg": "image/jpeg";
+            "image/png": "image/png";
+            "image/webp": "image/webp";
+        }>;
+        data: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingsRequestSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        "builder-multimodal-embedding": "builder-multimodal-embedding";
+    }>>;
+    inputType: z.ZodDefault<z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>>;
+    inputs: z.ZodArray<z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            mimeType: z.ZodEnum<{
+                "image/gif": "image/gif";
+                "image/jpeg": "image/jpeg";
+                "image/png": "image/png";
+                "image/webp": "image/webp";
+            }>;
+            data: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodOptional<z.ZodString>;
+        feature: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsRequestInput = z.input<typeof BuilderEmbeddingsRequestSchema>;
+export type BuilderEmbeddingsRequest = z.output<typeof BuilderEmbeddingsRequestSchema>;
+export declare const BuilderEmbeddingsResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"list">;
+    model: z.ZodObject<{
+        publicId: z.ZodLiteral<"builder-multimodal-embedding">;
+        provider: z.ZodLiteral<"voyage">;
+        providerModel: z.ZodLiteral<"voyage-multimodal-3.5">;
+        version: z.ZodLiteral<"3.5">;
+        dimensions: z.ZodLiteral<1024>;
+    }, z.core.$strip>;
+    inputType: z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"embedding">;
+        index: z.ZodNumber;
+        embedding: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    usage: z.ZodObject<{
+        textTokens: z.ZodNumber;
+        imagePixels: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsResponse = z.infer<typeof BuilderEmbeddingsResponseSchema>;

package/src/embeddings.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export const BUILDER_EMBEDDING_IMAGE_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+];
+const MAX_IMAGE_BASE64_LENGTH = 14000000;
+const MAX_REQUEST_BASE64_LENGTH = 24000000;
+const MAX_REQUEST_TEXT_LENGTH = 256000;
+export const BuilderEmbeddingImageSchema = z.object({
+    mimeType: z.enum(BUILDER_EMBEDDING_IMAGE_MIME_TYPES),
+    data: z
+        .string()
+        .min(1)
+        .max(MAX_IMAGE_BASE64_LENGTH)
+        .regex(/^[A-Za-z0-9+/]*={0,2}$/, "Image data must be raw base64."),
+});
+export const BuilderEmbeddingInputSchema = z
+    .object({
+    text: z.string().trim().min(1).max(32000).optional(),
+    images: z.array(BuilderEmbeddingImageSchema).max(6).default([]),
+})
+    .superRefine((input, ctx) => {
+    if (!input.text && input.images.length === 0) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Each input must contain text, an image, or both.",
+        });
+    }
+});
+export const BuilderEmbeddingsRequestSchema = z
+    .object({
+    model: z.enum(["auto", BUILDER_EMBEDDING_MODEL]).default("auto"),
+    inputType: z.enum(["query", "document"]).default("document"),
+    inputs: z.array(BuilderEmbeddingInputSchema).min(1).max(32),
+    source: z
+        .object({
+        appId: z.string().max(100).optional(),
+        feature: z.string().max(100).optional(),
+        resourceId: z.string().max(200).optional(),
+        userId: z.string().max(200).optional(),
+    })
+        .optional(),
+    metadata: z.record(z.string().max(100), z.string().max(1000)).optional(),
+})
+    .superRefine((request, ctx) => {
+    var _a;
+    var _b;
+    let base64Length = 0;
+    let textLength = 0;
+    for (const input of request.inputs) {
+        textLength += (_b = (_a = input.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        for (const image of input.images)
+            base64Length += image.data.length;
+    }
+    if (base64Length > MAX_REQUEST_BASE64_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_BASE64_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined image data is too large.",
+            path: ["inputs"],
+        });
+    }
+    if (textLength > MAX_REQUEST_TEXT_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_TEXT_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined text input is too large.",
+            path: ["inputs"],
+        });
+    }
+})
+    .meta({
+    description: "Request body for POST /agent-native/embeddings/v1/embeddings.",
+});
+export const BuilderEmbeddingsResponseSchema = z.object({
+    id: z.string(),
+    object: z.literal("list"),
+    model: z.object({
+        publicId: z.literal(BUILDER_EMBEDDING_MODEL),
+        provider: z.literal("voyage"),
+        providerModel: z.literal("voyage-multimodal-3.5"),
+        version: z.literal("3.5"),
+        dimensions: z.literal(BUILDER_EMBEDDING_DIMENSIONS),
+    }),
+    inputType: z.enum(["query", "document"]),
+    data: z.array(z.object({
+        object: z.literal("embedding"),
+        index: z.number().int().nonnegative(),
+        embedding: z
+            .array(z.number().finite())
+            .length(BUILDER_EMBEDDING_DIMENSIONS),
+    })),
+    usage: z.object({
+        textTokens: z.number().int().nonnegative(),
+        imagePixels: z.number().int().nonnegative(),
+        totalTokens: z.number().int().nonnegative(),
+    }),
+});

package/src/embeddings.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/embeddings.spec.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { BUILDER_EMBEDDING_MODEL, BuilderEmbeddingsRequestSchema, } from "./embeddings";
+describe("BuilderEmbeddingsRequestSchema", () => {
+    it("accepts retrieval text and multimodal inputs", () => {
+        var _a;
+        const parsed = BuilderEmbeddingsRequestSchema.parse({
+            model: BUILDER_EMBEDDING_MODEL,
+            inputType: "document",
+            inputs: [
+                { text: "A product launch slide" },
+                {
+                    text: "A warm editorial campaign",
+                    images: [{ mimeType: "image/png", data: "aGVsbG8=" }],
+                },
+            ],
+        });
+        expect(parsed.inputs).toHaveLength(2);
+        expect((_a = parsed.inputs[1]) === null || _a === void 0 ? void 0 : _a.images).toHaveLength(1);
+    });
+    it("rejects empty inputs and data URLs", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({ inputs: [{}] })).toThrow(/text, an image, or both/);
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [
+                {
+                    images: [
+                        {
+                            mimeType: "image/png",
+                            data: "data:image/png;base64,aGVsbG8=",
+                        },
+                    ],
+                },
+            ],
+        })).toThrow(/raw base64/);
+    });
+    it("rejects unsupported image formats and oversized batches", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [{ images: [{ mimeType: "image/svg+xml", data: "PHN2Zz4=" }] }],
+        })).toThrow();
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: Array.from({ length: 33 }, () => ({ text: "text" })),
+        })).toThrow();
+    });
+});

package/src/index.d.ts

@@ -19,4 +19,7 @@ export * from "./connectivity/types.js";
 export * from "./connectivity/classify.js";
 export * from "./single-tenancy.js";
 export * from "./design-systems.js";
+export * from "./editor-ai.js";
+export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/index.js

@@ -19,4 +19,7 @@ export * from "./connectivity/types.js";
 export * from "./connectivity/classify.js";
 export * from "./single-tenancy.js";
 export * from "./design-systems.js";
+export * from "./editor-ai.js";
+export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/messages.d.ts

@@ -93,6 +93,14 @@ export interface MCPServerURLDefinition {
     serverId: string;
     disabled: boolean;
     clientName?: string;
+    /**
+     * Per-server opt-in to the LLM-driven `mcp__<name>__authenticate` flow,
+     * independent of the `codegen-tool-mcp-authenticate` LD flag. Set on the
+     * Firestore `mcpServers` doc to roll the tool out to one server at a time;
+     * the LD flag remains the org-wide switch. Either being true opts the
+     * server in, so the flag can still turn it on everywhere at once.
+     */
+    useAuthenticateTool?: boolean;
 }
 export interface MCPServerToolConfiguration {
     allowed_tools?: Array<string> | null;
@@ -119,6 +127,13 @@ export interface MCPServerDoc<TCreateDate = unknown, TLegacyTokenExpiresAt = nev
     disabled?: boolean;
     clientName: string | undefined;
     tool_configuration?: MCPServerToolConfiguration | null;
+    /**
+     * Opt this server in to the LLM-driven `mcp__<name>__authenticate` tool
+     * instead of the blocking `mcp-auth-required` event, without turning on the
+     * org-wide `codegen-tool-mcp-authenticate` LD flag. Lets a single MCP server
+     * ship on the tool path ahead of the rest.
+     */
+    useAuthenticateTool?: boolean;
     oauthMetadata?: MCPServerOAuthMetadata | null;
     authorizationToken?: string;
     refreshToken?: string | null;

package/src/organization.d.ts

@@ -1,5 +1,11 @@
 import type { PrivacyMode, ReviewEffort } from "./codegen";
 import type { EnvironmentVariable } from "./common-schemas";
+export interface GitlabEnterpriseSetupValue {
+    host: string;
+    secondaryHost?: string;
+    setupType: "oauth" | "pat";
+    clientId?: string;
+}
 export interface GithubEnterpriseSetupValue {
     host: string;
     clientId: string;
@@ -19,6 +25,8 @@ export interface GitlabEnterprisePATValue {
     host: string;
     botUsername: string;
     secondaryHost?: string;
+    createdBy?: string;
+    createdAt?: number;
 }
 export interface GitlabCloudFallbackToken {
     token: string;
@@ -79,6 +87,7 @@ interface OrganizationSettings {
     isUserPluginIntegrationRequestGranted?: boolean;
     shopify?: boolean;
     githubEnterpriseSetupValue?: GithubEnterpriseSetupValue;
+    gitlabEnterpriseSetupValue?: GitlabEnterpriseSetupValue;
     gitlabEnterprisePAT?: GitlabEnterprisePATValue;
     gitlabCloudFallbackToken?: GitlabCloudFallbackToken;
     azureCloudFallbackToken?: AzureCloudFallbackToken;

package/src/projects.d.ts

@@ -153,7 +153,7 @@ export interface ReadyMessage extends BaseMessage {
 }
 export type MachineState = "unknown" | "created" | "starting" | "started" | "stopping" | "stopped" | "suspending" | "suspended" | "replacing" | "destroying" | "destroyed" | "not-found" | "running" | "failed";
 export type FlyVolumeState = "unknown" | "creating" | "created" | "extending" | "restoring" | "enabling_remote_export" | "hydrating" | "recovering" | "scheduling_destroy" | "pending_destroy" | "failed";
-export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable";
+export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable" | "git-auth-reauth-required";
 /**
  * Git provider types for diagnostics.
  */
@@ -909,12 +909,6 @@ export interface Project {
     deletedAt?: InMigrationDateNullable;
     /** User ID of whoever deleted the project. */
     deletedBy?: string;
-    /**
-     * When true, branches are stored in the standalone `branches` collection
-     * instead of embedded in project.branches field.
-     * Defaults to false for backwards compatibility with existing projects.
-     */
-    useBranchesCollection?: boolean;
     /** When true, the project is in code-only mode */
     codeOnlyMode?: boolean;
     /**
@@ -1075,8 +1069,6 @@ export interface CreateProjectOptions {
     autoApplySetup?: boolean;
     templateId?: string;
     useInternalHost?: boolean;
-    /** Store branches in the standalone `branches` collection vs embedded in the project doc. */
-    useBranchesCollection?: boolean;
     /** @internal Read-only source repo cloned to bootstrap the project. Carried through to Firestore. */
     templateRepoUrl?: string;
     /** @internal First-class hosting config copied from the template. Carried through to Firestore. */
@@ -1728,7 +1720,6 @@ export declare const CloneProjectOptionsSchema: z.ZodObject<{
     }>;
     userEmail: z.ZodOptional<z.ZodString>;
     useKube: z.ZodDefault<z.ZodBoolean>;
-    useBranchesCollection: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type CloneProjectOptions = z.infer<typeof CloneProjectOptionsSchema>;
 export declare const DuplicateBranchOptionsSchema: z.ZodObject<{

package/src/projects.js

@@ -640,13 +640,6 @@ export const CloneProjectOptionsSchema = z.object({
     useKube: z.boolean().default(false).meta({
         description: "Whether to provision on cloud-v2 (Kubernetes). Defaults to false.",
     }),
-    useBranchesCollection: z
-        .boolean()
-        .default(false)
-        .meta({
-        description: "Whether the new project stores branches in the standalone `branches` " +
-            "collection rather than embedded in the project doc. Defaults to false.",
-    }),
 });
 export const DuplicateBranchOptionsSchema = z.object({
     projectId: z.string().min(1).meta({

package/src/proxy.d.ts

@@ -20,7 +20,7 @@ export interface ProxyConfig {
  *
  * `proxyDestination` is always passed through unchanged.
  */
-export declare function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination }: ProxyConfig): {
+export declare function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination, }: ProxyConfig): {
     proxyOrigin: string | undefined;
     proxyDefaultOrigin: string | undefined;
     proxyDestination: string | undefined;

package/src/realtime.d.ts

@@ -0,0 +1,232 @@
+import { z } from "zod";
+export declare const BUILDER_REALTIME_MODEL: "gpt-realtime-2.1";
+export declare const BUILDER_REALTIME_MAX_SDP_LENGTH = 256000;
+export declare const BUILDER_REALTIME_MAX_SESSION_BYTES = 64000;
+export declare const OpenAIRealtimeFunctionToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OpenAIRealtimeFunctionTool = z.infer<typeof OpenAIRealtimeFunctionToolSchema>;
+export declare const OpenAIRealtimeMcpToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"mcp">;
+    server_label: z.ZodString;
+    server_url: z.ZodOptional<z.ZodURL>;
+    server_description: z.ZodOptional<z.ZodString>;
+    authorization: z.ZodOptional<z.ZodString>;
+    allowed_tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    require_approval: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        always: "always";
+        never: "never";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+}, z.core.$strip>;
+export type OpenAIRealtimeMcpTool = z.infer<typeof OpenAIRealtimeMcpToolSchema>;
+export declare const OpenAIRealtimeToolSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"mcp">;
+    server_label: z.ZodString;
+    server_url: z.ZodOptional<z.ZodURL>;
+    server_description: z.ZodOptional<z.ZodString>;
+    authorization: z.ZodOptional<z.ZodString>;
+    allowed_tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    require_approval: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        always: "always";
+        never: "never";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+}, z.core.$strip>], "type">;
+export type OpenAIRealtimeTool = z.infer<typeof OpenAIRealtimeToolSchema>;
+/**
+ * The subset of OpenAI's Realtime session configuration accepted by Builder
+ * Connect. Zod objects intentionally strip unknown keys before this config is
+ * forwarded to OpenAI.
+ */
+export declare const OpenAIRealtimeSessionConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"realtime">;
+    model: z.ZodLiteral<"gpt-realtime-2.1">;
+    output_modalities: z.ZodTuple<[z.ZodLiteral<"audio">], null>;
+    instructions: z.ZodOptional<z.ZodString>;
+    audio: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodObject<{
+            format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+            noise_reduction: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    far_field: "far_field";
+                    near_field: "near_field";
+                }>;
+            }, z.core.$strip>>>;
+            transcription: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                model: z.ZodLiteral<"gpt-4o-mini-transcribe">;
+                language: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            turn_detection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    semantic_vad: "semantic_vad";
+                    server_vad: "server_vad";
+                }>;
+                threshold: z.ZodOptional<z.ZodNumber>;
+                prefix_padding_ms: z.ZodOptional<z.ZodNumber>;
+                silence_duration_ms: z.ZodOptional<z.ZodNumber>;
+                idle_timeout_ms: z.ZodOptional<z.ZodNumber>;
+                eagerness: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    high: "high";
+                    low: "low";
+                    medium: "medium";
+                }>>;
+                create_response: z.ZodOptional<z.ZodBoolean>;
+                interrupt_response: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        output: z.ZodOptional<z.ZodObject<{
+            format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+            voice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>]>>;
+            speed: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        strict: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcp">;
+        server_label: z.ZodString;
+        server_url: z.ZodOptional<z.ZodURL>;
+        server_description: z.ZodOptional<z.ZodString>;
+        authorization: z.ZodOptional<z.ZodString>;
+        allowed_tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        require_approval: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            always: "always";
+            never: "never";
+        }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    }, z.core.$strip>], "type">>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        auto: "auto";
+        none: "none";
+        required: "required";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcp">;
+        server_label: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    max_output_tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inf">, z.ZodNumber]>>;
+    prompt: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    tracing: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+    truncation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        auto: "auto";
+        disabled: "disabled";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type OpenAIRealtimeSessionConfig = z.infer<typeof OpenAIRealtimeSessionConfigSchema>;
+export declare const BuilderRealtimeSessionRequestSchema: z.ZodObject<{
+    sdp: z.ZodString;
+    session: z.ZodObject<{
+        type: z.ZodLiteral<"realtime">;
+        model: z.ZodLiteral<"gpt-realtime-2.1">;
+        output_modalities: z.ZodTuple<[z.ZodLiteral<"audio">], null>;
+        instructions: z.ZodOptional<z.ZodString>;
+        audio: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodObject<{
+                format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+                noise_reduction: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        far_field: "far_field";
+                        near_field: "near_field";
+                    }>;
+                }, z.core.$strip>>>;
+                transcription: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    model: z.ZodLiteral<"gpt-4o-mini-transcribe">;
+                    language: z.ZodOptional<z.ZodString>;
+                    prompt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                turn_detection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        semantic_vad: "semantic_vad";
+                        server_vad: "server_vad";
+                    }>;
+                    threshold: z.ZodOptional<z.ZodNumber>;
+                    prefix_padding_ms: z.ZodOptional<z.ZodNumber>;
+                    silence_duration_ms: z.ZodOptional<z.ZodNumber>;
+                    idle_timeout_ms: z.ZodOptional<z.ZodNumber>;
+                    eagerness: z.ZodOptional<z.ZodEnum<{
+                        auto: "auto";
+                        high: "high";
+                        low: "low";
+                        medium: "medium";
+                    }>>;
+                    create_response: z.ZodOptional<z.ZodBoolean>;
+                    interrupt_response: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodObject<{
+                format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+                voice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                }, z.core.$strip>]>>;
+                speed: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mcp">;
+            server_label: z.ZodString;
+            server_url: z.ZodOptional<z.ZodURL>;
+            server_description: z.ZodOptional<z.ZodString>;
+            authorization: z.ZodOptional<z.ZodString>;
+            allowed_tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+            require_approval: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                always: "always";
+                never: "never";
+            }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        }, z.core.$strip>], "type">>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            auto: "auto";
+            none: "none";
+            required: "required";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mcp">;
+            server_label: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        max_output_tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inf">, z.ZodNumber]>>;
+        prompt: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        tracing: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+        truncation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            auto: "auto";
+            disabled: "disabled";
+        }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BuilderRealtimeSessionRequest = z.infer<typeof BuilderRealtimeSessionRequestSchema>;