@builder.io/ai-utils 0.99.0 → 0.100.0

package/src/projects.js

@@ -308,18 +308,37 @@ export const ShapeAnswerSchema = z.object({
     llmOptionId: z.string().optional(),
     guessOptionId: z.string().optional(),
 });
+export const ShapeQuestionDecisionSchema = z.object({
+    questionId: z.string(),
+    ask: z.boolean(),
+    llmOptionId: z.string().optional(),
+    confidence: z.number().optional(),
+    guessOptionId: z.string(),
+});
 export const ShapeSessionSchema = z.object({
     questionnaireId: z.string(),
     catalogVersion: z.string().regex(/^\d{4}-\d{2}-\d{2}\.\d+$/),
     source: z.enum(["static", "agent"]),
     status: z.enum(["assembling", "pending", "resolved"]),
-    selection: z.enum(["llm", "fallback"]),
+    selection: z.enum(["llm", "fallback"]).optional(),
+    decisions: z.array(ShapeQuestionDecisionSchema).optional(),
     questions: z.array(ShapeQuestionSchema),
     initialPromptId: z.string(),
     answers: z.array(ShapeAnswerSchema).optional(),
+    issuedAt: z.string().optional(),
     assembledAt: z.string().optional(),
     resolvedAt: z.string().optional(),
 });
+export const InitialPromptSchema = z.object({
+    id: z.string(),
+    projectId: z.string(),
+    branchName: z.string().optional(),
+    prompt: z.string(),
+    attachmentIds: z.array(z.string()).optional(),
+    createdBy: z.string(),
+    createdAt: z.number(),
+    deliveredAt: z.number().optional(),
+});
 export const ProjectRolePermissionsSchema = z
     .object({
     view: z.boolean().optional(),
@@ -861,8 +880,9 @@ export const getBranchState = (branch) => {
  * Get the state of a project, checking `state` first and falling back to `deleted` for backwards compatibility.
  */
 export const getProjectState = (project) => {
-    var _a;
-    return (_a = project.state) !== null && _a !== void 0 ? _a : "active";
+    if (project.state)
+        return project.state;
+    return project.deleted ? "deleted" : "active";
 };
 /**
  * Check if a branch is deleted, supporting both `state` and legacy `deleted` fields.
@@ -1753,6 +1773,17 @@ export const GetHostingAiUsageResponseSchema = z.object({
      */
     coreSupportsGateway: z.boolean(),
     token: HostingAiUsageTokenStatusSchema.nullable(),
+    /**
+     * The `AI_USAGE_MANAGED_PROD_ENV_KEYS` currently holding a value the deployed
+     * site will see, names only. The client cannot derive this: the write endpoint
+     * deliberately leaves the caller's project model stale, so anything projected
+     * locally is wrong the moment two writes or an out-of-band env edit interleave.
+     *
+     * Absent on an API that predates the field, which a client must read as
+     * "unknown" and not as "none": reading it as none pre-selects a mode whose
+     * write deletes the customer's provider key.
+     */
+    managedProdEnvKeys: z.array(z.string()).optional(),
 });
 /** Providers a customer may bring their own key for. */
 export const AiUsageByokProviderSchema = z.enum(["anthropic", "openai"]);
@@ -1770,6 +1801,7 @@ export const SetHostingAiUsageRequestSchema = z.strictObject({
     mode: AiPaymentModeSchema,
     provider: AiUsageByokProviderSchema.optional(),
     apiKey: z.string().min(1).optional(),
+    reuseExistingKey: z.boolean().optional(),
     // https only: this value is written into a published site's prod env as
     // `OPENAI_BASE_URL`, so an `http://` endpoint would send the customer's
     // provider key and every prompt in plaintext from the deployed site.
@@ -1789,6 +1821,14 @@ export const SetHostingAiUsageResponseSchema = z.object({
      * mode), which is exactly the case where no redeploy is needed.
      */
     configUpdatedAt: z.number().optional(),
+    /**
+     * The `AI_USAGE_MANAGED_PROD_ENV_KEYS` present in prod env after the write.
+     * The client cannot derive this: its project model is deliberately not updated
+     * with the rewrite, so projecting it locally goes stale the moment two writes
+     * or an out-of-band env edit interleave. Optional so a client can still talk to
+     * an API that predates it.
+     */
+    managedProdEnvKeys: z.array(z.string()).optional(),
 });
 /** Body for `POST /projects/hosting/ai-usage/revoke`. */
 export const RevokeHostingAiTokenRequestSchema = z.strictObject({
@@ -2120,17 +2160,58 @@ export const ProjectTemplateOverridesSchema = z.object({
     settings: ProjectSettingsExternalSchema.partial().optional(),
     hosting: ProjectHostingExternalSchema.optional(),
 });
-export const CreateProjectTemplateFromProjectOptionsSchema = z.object({
-    sourceProjectId: z.string().min(1).meta({
-        description: "Project whose settings, repo fields, and hosting config seed the template.",
-    }),
-    sourceBranchName: z.string().min(1).meta({
-        description: "Branch of the source project that projects created from this template are seeded from.",
+/** Mirrors `ProjectSourceSchema`'s repo/template split for project creation. */
+export const CreateTemplateSourceSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("project"),
+        sourceProjectId: z.string().min(1).meta({
+            description: "Project whose settings, repo fields, and hosting config seed the template.",
+        }),
+        sourceBranchName: z.string().min(1).meta({
+            description: "Branch of the source project that projects created from this template are seeded from.",
+        }),
     }),
-    overrides: ProjectTemplateOverridesSchema.optional().meta({
-        description: "Fields to override on top of the values copied from the source project.",
+    z.object({
+        kind: z.literal("template"),
+        templateId: z.string().min(1).meta({
+            description: "Built-in stub or custom template id whose settings, repo fields, and hosting config seed the new template.",
+        }),
     }),
+]);
+/**
+ * Deprecation-window shim for callers still sending the old flat
+ * `{ sourceProjectId, sourceBranchName }` shape — safe to delete once no
+ * caller sends it anymore.
+ */
+const LegacyFlatTemplateSourceSchema = z.object({
+    sourceProjectId: z.string().min(1),
+    sourceBranchName: z.string().min(1),
 });
+export const CreateProjectTemplateFromProjectOptionsSchema = z
+    .union([
+    z.object({
+        source: CreateTemplateSourceSchema.meta({
+            description: "The project or template whose settings, repo fields, and hosting config seed the new template.",
+        }),
+        overrides: ProjectTemplateOverridesSchema.optional().meta({
+            description: "Fields to override on top of the values copied from the source.",
+        }),
+    }),
+    z.object({
+        ...LegacyFlatTemplateSourceSchema.shape,
+        overrides: ProjectTemplateOverridesSchema.optional(),
+    }),
+])
+    .transform((parsed) => "source" in parsed
+    ? parsed
+    : {
+        source: {
+            kind: "project",
+            sourceProjectId: parsed.sourceProjectId,
+            sourceBranchName: parsed.sourceBranchName,
+        },
+        overrides: parsed.overrides,
+    });
 /**
  * Deliberately minimal: the stored template carries plaintext secret env values,
  * so nothing beyond the identity of the new template goes back to the caller.

package/src/projects.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { AGENT_NATIVE_STARTER_REPO, getAgentNativeRootPackageJsonWriteError, getManagedDatabasePackageJsonError, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, ProjectSettingsSchema, ProjectTemplateOverridesSchema, ShapeSessionSchema, } from "./projects";
+import { AGENT_NATIVE_STARTER_REPO, getAgentNativeRootPackageJsonWriteError, getManagedDatabasePackageJsonError, getProjectState, InitialPromptSchema, isProjectDeleted, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, ProjectSettingsSchema, ProjectTemplateOverridesSchema, ShapeSessionSchema, } from "./projects";
 describe("project hosting schemas", () => {
     it("accepts the canonical published branch route", () => {
         expect(ProjectHostingSchema.parse({ publishedBranchId: "branch-live" })).toEqual({ publishedBranchId: "branch-live" });
@@ -42,6 +42,16 @@ describe("guided onboarding project settings", () => {
             },
         ],
         initialPromptId: "prompt-1",
+        issuedAt: "2026-09-09T12:00:00.000Z",
+        decisions: [
+            {
+                questionId: "authentication",
+                ask: false,
+                llmOptionId: "required",
+                confidence: 0.99,
+                guessOptionId: "required",
+            },
+        ],
     };
     it("parses a snapshotted questionnaire session", () => {
         expect(ShapeSessionSchema.parse(shapeSession)).toEqual(shapeSession);
@@ -55,6 +65,16 @@ describe("guided onboarding project settings", () => {
             catalogVersion: "v1",
         })).toThrow();
     });
+    it("parses a project-level initial prompt", () => {
+        const initialPrompt = {
+            id: "prompt-1",
+            projectId: "project-1",
+            prompt: "Build an expense tracker",
+            createdBy: "user-1",
+            createdAt: 1788952800000,
+        };
+        expect(InitialPromptSchema.parse(initialPrompt)).toEqual(initialPrompt);
+    });
     it("does not allow clients to write a shape session", () => {
         expect(ProjectSettingsExternalSchema.parse({ shapeSession })).toEqual({});
         expect(ProjectTemplateOverridesSchema.parse({ settings: { shapeSession } })).toEqual({ settings: {} });
@@ -136,3 +156,22 @@ describe("getAgentNativeRootPackageJsonWriteError", () => {
         })).toBeUndefined();
     });
 });
+describe("getProjectState", () => {
+    const project = (fields) => fields;
+    it("prefers the state field", () => {
+        expect(getProjectState(project({ state: "archived" }))).toBe("archived");
+        expect(isProjectDeleted(project({ state: "deleted" }))).toBe(true);
+    });
+    it("falls back to the legacy deleted field", () => {
+        expect(getProjectState(project({ deleted: true }))).toBe("deleted");
+        expect(isProjectDeleted(project({ deleted: true }))).toBe(true);
+    });
+    /** A restored project keeps `deleted: true` but gets an explicit state. */
+    it("lets an explicit state win over the legacy field", () => {
+        expect(isProjectDeleted(project({ state: "active", deleted: true }))).toBe(false);
+    });
+    it("defaults to active", () => {
+        expect(getProjectState(project({}))).toBe("active");
+        expect(isProjectDeleted(project({ deleted: false }))).toBe(false);
+    });
+});

package/src/publish-agent.d.ts

@@ -1,5 +1,18 @@
 import type { GenerateCompletionStep } from "./codegen.js";
 import { z } from "zod";
+/**
+ * Client-safe metadata for a Publish Agent skill: enough for a picker UI
+ * (id, name, description), without the instruction `content` sent to the
+ * model. `id` is the shared key the server uses to attach that content —
+ * see `PUBLISH_AGENT_SKILLS` in `packages/service/publish-agent/config.ts`.
+ */
+export declare const PublishAgentSkillInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export type PublishAgentSkillInfo = z.infer<typeof PublishAgentSkillInfoSchema>;
+export declare const PUBLISH_AGENT_SKILLS_INFO: readonly PublishAgentSkillInfo[];
 export declare const PublishAgentSessionCursorSchema: z.ZodObject<{
     updatedAt: z.ZodNumber;
     id: z.ZodString;

package/src/publish-agent.js

@@ -1,4 +1,24 @@
 import { z } from "zod";
+/**
+ * Client-safe metadata for a Publish Agent skill: enough for a picker UI
+ * (id, name, description), without the instruction `content` sent to the
+ * model. `id` is the shared key the server uses to attach that content —
+ * see `PUBLISH_AGENT_SKILLS` in `packages/service/publish-agent/config.ts`.
+ */
+export const PublishAgentSkillInfoSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+})
+    .meta({ title: "PublishAgentSkillInfo" });
+export const PUBLISH_AGENT_SKILLS_INFO = [
+    {
+        id: "publish-agent-skill-create-page",
+        name: "create-page",
+        description: "Create a new page in the Builder CMS space. Use when the user asks to create, add, or scaffold a new page.",
+    },
+];
 export const PublishAgentSessionCursorSchema = z
     .object({
     updatedAt: z.number().int(),

package/src/realtime.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
-export declare const BUILDER_REALTIME_MODEL: "gpt-realtime-2.1";
+export declare const BUILDER_REALTIME_MODEL: "gpt-live-1";
+export declare const BUILDER_REALTIME_LEGACY_MODEL: "gpt-realtime-2.1";
+export declare const BUILDER_REALTIME_DELEGATED_MODEL: "gpt-5.6-luna";
 export declare const BUILDER_REALTIME_MAX_SDP_LENGTH = 256000;
 export declare const BUILDER_REALTIME_MAX_SESSION_BYTES = 64000;
 export declare const OpenAIRealtimeFunctionToolSchema: z.ZodObject<{
@@ -137,9 +139,122 @@ export declare const OpenAIRealtimeSessionConfigSchema: z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type OpenAIRealtimeSessionConfig = z.infer<typeof OpenAIRealtimeSessionConfigSchema>;
+/** The subset of GPT-Live session configuration accepted by Builder Connect. */
+export declare const OpenAILiveSessionConfigSchema: z.ZodObject<{
+    model: z.ZodLiteral<"gpt-live-1">;
+    instructions: z.ZodOptional<z.ZodString>;
+    audio: z.ZodOptional<z.ZodObject<{
+        output: z.ZodOptional<z.ZodObject<{
+            voice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    delegation: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"responses">;
+        responses: z.ZodObject<{
+            model: z.ZodLiteral<"gpt-5.6-luna">;
+            instructions: z.ZodOptional<z.ZodString>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [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<"web_search">;
+            }, z.core.$strip>]>>>;
+            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>]>>;
+            parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            service_tier: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                default: "default";
+                priority: "priority";
+            }>>;
+            reasoning: z.ZodOptional<z.ZodObject<{
+                effort: z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    none: "none";
+                    xhigh: "xhigh";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"client">;
+    }, z.core.$strip>]>>>;
+    store: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OpenAILiveSessionConfig = z.infer<typeof OpenAILiveSessionConfigSchema>;
 export declare const BuilderRealtimeSessionRequestSchema: z.ZodObject<{
     sdp: z.ZodString;
-    session: z.ZodObject<{
+    session: z.ZodUnion<readonly [z.ZodObject<{
+        model: z.ZodLiteral<"gpt-live-1">;
+        instructions: z.ZodOptional<z.ZodString>;
+        audio: z.ZodOptional<z.ZodObject<{
+            output: z.ZodOptional<z.ZodObject<{
+                voice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        delegation: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"responses">;
+            responses: z.ZodObject<{
+                model: z.ZodLiteral<"gpt-5.6-luna">;
+                instructions: z.ZodOptional<z.ZodString>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [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<"web_search">;
+                }, z.core.$strip>]>>>;
+                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>]>>;
+                parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+                max_output_tokens: z.ZodOptional<z.ZodNumber>;
+                service_tier: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    default: "default";
+                    priority: "priority";
+                }>>;
+                reasoning: z.ZodOptional<z.ZodObject<{
+                    effort: z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        max: "max";
+                        medium: "medium";
+                        minimal: "minimal";
+                        none: "none";
+                        xhigh: "xhigh";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"client">;
+        }, z.core.$strip>]>>>;
+        store: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"realtime">;
         model: z.ZodLiteral<"gpt-realtime-2.1">;
         output_modalities: z.ZodTuple<[z.ZodLiteral<"audio">], null>;
@@ -227,6 +342,6 @@ export declare const BuilderRealtimeSessionRequestSchema: z.ZodObject<{
             disabled: "disabled";
         }>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
         include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
+    }, z.core.$strip>]>;
 }, z.core.$strip>;
 export type BuilderRealtimeSessionRequest = z.infer<typeof BuilderRealtimeSessionRequestSchema>;

package/src/realtime.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
-export const BUILDER_REALTIME_MODEL = "gpt-realtime-2.1";
+export const BUILDER_REALTIME_MODEL = "gpt-live-1";
+export const BUILDER_REALTIME_LEGACY_MODEL = "gpt-realtime-2.1";
+export const BUILDER_REALTIME_DELEGATED_MODEL = "gpt-5.6-luna";
 export const BUILDER_REALTIME_MAX_SDP_LENGTH = 256000;
 export const BUILDER_REALTIME_MAX_SESSION_BYTES = 64000;
 const utf8ByteLength = (value) => new TextEncoder().encode(value).length;
@@ -109,7 +111,7 @@ const OpenAIRealtimeToolChoiceSchema = z.union([
 export const OpenAIRealtimeSessionConfigSchema = z
     .object({
     type: z.literal("realtime"),
-    model: z.literal(BUILDER_REALTIME_MODEL),
+    model: z.literal(BUILDER_REALTIME_LEGACY_MODEL),
     output_modalities: z.tuple([z.literal("audio")]),
     instructions: z.string().max(32000).optional(),
     audio: z
@@ -148,11 +150,76 @@ export const OpenAIRealtimeSessionConfigSchema = z
 })
     .refine((session) => utf8ByteLength(JSON.stringify(session)) <=
     BUILDER_REALTIME_MAX_SESSION_BYTES, { message: "Realtime session configuration is too large" });
+const OpenAILiveToolSchema = z.union([
+    OpenAIRealtimeFunctionToolSchema,
+    z.object({ type: z.literal("web_search") }),
+]);
+const OpenAILiveResponsesDelegationSchema = z.object({
+    model: z.literal(BUILDER_REALTIME_DELEGATED_MODEL),
+    instructions: z.string().max(32000).optional(),
+    tools: z.array(OpenAILiveToolSchema).max(32).optional(),
+    tool_choice: z
+        .union([
+        z.enum(["auto", "none", "required"]),
+        z.object({
+            type: z.literal("function"),
+            name: z.string().min(1).max(64),
+        }),
+    ])
+        .optional(),
+    parallel_tool_calls: z.boolean().optional(),
+    max_output_tokens: z.number().int().min(16).max(4096).optional(),
+    service_tier: z.enum(["auto", "default", "priority"]).optional(),
+    reasoning: z
+        .object({
+        effort: z.enum([
+            "none",
+            "minimal",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max",
+        ]),
+    })
+        .optional(),
+});
+const OpenAILiveDelegationSchema = z.union([
+    z.object({
+        type: z.literal("responses"),
+        responses: OpenAILiveResponsesDelegationSchema,
+    }),
+    z.object({ type: z.literal("client") }),
+]);
+const OpenAILiveOutputAudioSchema = z.object({
+    voice: z
+        .union([
+        z.string().min(1).max(128),
+        z.object({ id: z.string().min(1).max(256) }),
+    ])
+        .optional(),
+});
+/** The subset of GPT-Live session configuration accepted by Builder Connect. */
+export const OpenAILiveSessionConfigSchema = z
+    .object({
+    model: z.literal(BUILDER_REALTIME_MODEL),
+    instructions: z.string().max(32000).optional(),
+    audio: z
+        .object({ output: OpenAILiveOutputAudioSchema.optional() })
+        .optional(),
+    delegation: OpenAILiveDelegationSchema.nullable().optional(),
+    store: z.boolean().optional(),
+})
+    .refine((session) => utf8ByteLength(JSON.stringify(session)) <=
+    BUILDER_REALTIME_MAX_SESSION_BYTES, { message: "Live session configuration is too large" });
 export const BuilderRealtimeSessionRequestSchema = z.object({
     sdp: z
         .string()
         .min(1)
         .max(BUILDER_REALTIME_MAX_SDP_LENGTH)
         .refine((sdp) => sdp.trim().length > 0, { message: "SDP cannot be blank" }),
-    session: OpenAIRealtimeSessionConfigSchema,
+    session: z.union([
+        OpenAILiveSessionConfigSchema,
+        OpenAIRealtimeSessionConfigSchema,
+    ]),
 });

package/src/realtime.spec.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { BUILDER_REALTIME_MAX_SDP_LENGTH, BuilderRealtimeSessionRequestSchema, OpenAIRealtimeSessionConfigSchema, } from "./realtime.js";
+import { BUILDER_REALTIME_MAX_SDP_LENGTH, BuilderRealtimeSessionRequestSchema, OpenAILiveSessionConfigSchema, OpenAIRealtimeSessionConfigSchema, } from "./realtime.js";
 const validSession = {
     type: "realtime",
     model: "gpt-realtime-2.1",
@@ -7,6 +7,38 @@ const validSession = {
     instructions: "Help the user operate their Builder app.",
 };
 describe("BuilderRealtimeSessionRequestSchema", () => {
+    it("accepts a GPT-Live WebRTC session with Responses delegation", () => {
+        const result = BuilderRealtimeSessionRequestSchema.parse({
+            sdp: "v=0\r\no=- 1 1 IN IP4 127.0.0.1",
+            session: {
+                model: "gpt-live-1",
+                instructions: "Help the user operate their Builder app.",
+                audio: { output: { voice: "marin" } },
+                delegation: {
+                    type: "responses",
+                    responses: {
+                        model: "gpt-5.6-luna",
+                        tools: [
+                            {
+                                type: "function",
+                                name: "navigate",
+                                parameters: { type: "object", properties: {} },
+                            },
+                            { type: "web_search" },
+                        ],
+                        reasoning: { effort: "minimal" },
+                    },
+                },
+            },
+        });
+        expect(result.session).toMatchObject({
+            model: "gpt-live-1",
+            delegation: {
+                type: "responses",
+                responses: { model: "gpt-5.6-luna" },
+            },
+        });
+    });
     it("accepts a bounded audio session with tools", () => {
         var _a;
         const result = BuilderRealtimeSessionRequestSchema.parse({
@@ -39,10 +71,13 @@ describe("BuilderRealtimeSessionRequestSchema", () => {
             },
         });
         expect(result.session.model).toBe("gpt-realtime-2.1");
-        expect((_a = result.session.tools) === null || _a === void 0 ? void 0 : _a[0]).toMatchObject({
-            type: "function",
-            name: "navigate",
-        });
+        expect("tools" in result.session).toBe(true);
+        if ("tools" in result.session) {
+            expect((_a = result.session.tools) === null || _a === void 0 ? void 0 : _a[0]).toMatchObject({
+                type: "function",
+                name: "navigate",
+            });
+        }
     });
     it("strips unknown request, session, and known nested config keys", () => {
         const sdp = " v=0\r\n";
@@ -86,6 +121,19 @@ describe("BuilderRealtimeSessionRequestSchema", () => {
             },
         }).success).toBe(false);
     });
+    it("rejects unsupported GPT-Live delegation types", () => {
+        expect(OpenAILiveSessionConfigSchema.safeParse({
+            model: "gpt-live-1",
+            delegation: { type: "unknown" },
+        }).success).toBe(false);
+        expect(OpenAILiveSessionConfigSchema.safeParse({
+            model: "gpt-live-1",
+            delegation: {
+                type: "responses",
+                responses: { model: "gpt-5.6" },
+            },
+        }).success).toBe(false);
+    });
     it("rejects empty and oversized SDP offers", () => {
         expect(BuilderRealtimeSessionRequestSchema.safeParse({
             sdp: "   ",