@builder.io/ai-utils 0.99.0 → 0.100.1

package/src/projects.js

@@ -279,7 +279,10 @@ export const ShapeEffectSchema = z.discriminatedUnion("kind", [
     }),
     z.object({
         kind: z.literal("attach-design-system"),
+        /** The permanent join key. */
         designSystemId: z.string(),
+        /** What actually gets written: the field is matched by name downstream. */
+        designSystemName: z.string(),
     }),
 ]);
 export const ShapeOptionEffectSchema = z.object({
@@ -302,24 +305,93 @@ export const ShapeAnswerSchema = z.object({
     questionId: z.string(),
     optionId: z.string().optional(),
     designSystemId: z.string().optional(),
+    /**
+     * Server-resolved from `designSystemId` against the caller's accessible
+     * design systems. `settings.designSystems` is matched by name downstream, so
+     * the id alone cannot be written there.
+     */
+    designSystemName: z.string().optional(),
     skipped: z.boolean(),
     delegated: z.boolean(),
     resolvedFrom: z.enum(["user", "llm"]),
     llmOptionId: z.string().optional(),
     guessOptionId: z.string().optional(),
 });
+const ShapeAnswerInputBaseSchema = ShapeAnswerSchema.pick({
+    questionId: true,
+    optionId: true,
+    designSystemId: true,
+    skipped: true,
+    delegated: true,
+});
+export const ShapeAnswerInputSchema = z.object({
+    ...ShapeAnswerInputBaseSchema.shape,
+    questionId: ShapeAnswerInputBaseSchema.shape.questionId.trim().min(1),
+    optionId: ShapeAnswerInputBaseSchema.shape.optionId
+        .unwrap()
+        .trim()
+        .min(1)
+        .optional(),
+    designSystemId: ShapeAnswerInputBaseSchema.shape.designSystemId
+        .unwrap()
+        .trim()
+        .min(1)
+        .optional(),
+});
+export const GetShapeQuestionnaireOptionsSchema = z.object({
+    projectId: z.string().trim().min(1),
+});
+export const SubmitShapeAnswersOptionsSchema = z.object({
+    projectId: z.string().trim().min(1),
+    questionnaireId: z.string().trim().min(1),
+    answers: z.array(ShapeAnswerInputSchema).min(1),
+});
+/**
+ * A file the client writes into the container's working tree over the
+ * launch-server RPC. The server renders the body; the container performs the
+ * write; the agent only reads it.
+ */
+export const ShapeDecisionsFileSchema = z.object({
+    /** Repository-root relative. */
+    path: z.string().min(1),
+    contents: z.string().min(1),
+});
+export const SubmitShapeAnswersResponseSchema = z.object({
+    prompt: z.string().min(1),
+    instructionBlock: z.string().min(1).optional(),
+    decisionsFile: ShapeDecisionsFileSchema.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 +933,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 +1826,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 +1854,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 +1874,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 +2213,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, GetShapeQuestionnaireOptionsSchema, InitialPromptSchema, isProjectDeleted, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, ProjectSettingsSchema, ProjectTemplateOverridesSchema, ShapeSessionSchema, SubmitShapeAnswersOptionsSchema, } 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,10 +65,56 @@ 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: {} });
     });
+    it("parses questionnaire endpoint inputs without accepting server fields", () => {
+        expect(GetShapeQuestionnaireOptionsSchema.parse({ projectId: "project-1" })).toEqual({ projectId: "project-1" });
+        expect(SubmitShapeAnswersOptionsSchema.parse({
+            projectId: "project-1",
+            questionnaireId: "questionnaire-1",
+            answers: [
+                {
+                    questionId: "authentication",
+                    optionId: "required",
+                    skipped: false,
+                    delegated: false,
+                    resolvedFrom: "llm",
+                    llmOptionId: "not-required",
+                    guessOptionId: "not-required",
+                },
+            ],
+        })).toEqual({
+            projectId: "project-1",
+            questionnaireId: "questionnaire-1",
+            answers: [
+                {
+                    questionId: "authentication",
+                    optionId: "required",
+                    skipped: false,
+                    delegated: false,
+                },
+            ],
+        });
+    });
+    it("requires non-empty questionnaire ids and at least one answer", () => {
+        expect(() => SubmitShapeAnswersOptionsSchema.parse({
+            projectId: "",
+            questionnaireId: "",
+            answers: [],
+        })).toThrow();
+    });
 });
 describe("matchesAgentNativeStarter", () => {
     it("matches when repoName is the starter", () => {
@@ -136,3 +192,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,
+    ]),
 });