@builder.io/ai-utils 0.103.0 → 0.106.0

package/src/projects.js

@@ -399,6 +399,14 @@ export const ShapeSessionSchema = z.object({
     assembledAt: z.string().optional(),
     resolvedAt: z.string().optional(),
 });
+/**
+ * Stored shape of the top-level `shapeSessions/{projectId}` Firestore
+ * collection: a `ShapeSession` plus the `projectId` it belongs to, since the
+ * doc ID alone isn't visible once the doc is loaded into memory.
+ */
+export const ShapeSessionDocSchema = ShapeSessionSchema.extend({
+    projectId: z.string(),
+});
 export const InitialPromptSchema = z.object({
     id: z.string(),
     projectId: z.string(),
@@ -896,9 +904,6 @@ export const ProjectSettingsSchema = z
     })
         .optional()
         .meta({ description: "Password-protect the preview URL." }),
-    shapeSession: ShapeSessionSchema.optional().meta({
-        description: "@internal Guided-onboarding questionnaire issued for this project.",
-    }),
 })
     .meta({ title: "ProjectSettings" });
 /**
@@ -922,7 +927,6 @@ const INTERNAL_PROJECT_SETTINGS_MASK = {
     commitInstructions: true,
     skipCommandSecurity: true,
     autoCloseBranchOnMerge: true,
-    shapeSession: true,
 };
 /**
  * Runtime schema for the client-writable subset of {@link Project.settings},
@@ -2311,3 +2315,41 @@ export const CreateProjectTemplateFromProjectOptionsSchema = z
 export const CreateProjectTemplateFromProjectResponseSchema = z.object({
     template: ProjectTemplateSchema.pick({ id: true, name: true }),
 });
+export const ListProjectTemplatesOptionsSchema = z.object({
+    id: z.string().min(1).optional(),
+});
+export const ListProjectTemplatesResponseSchema = z.object({
+    templates: z.array(ProjectTemplateSchema),
+});
+export const UpdateProjectTemplateOptionsSchema = z.object({
+    id: z.string().min(1),
+    updates: ProjectTemplateOverridesSchema,
+});
+export const UpdateProjectTemplateResponseSchema = z.object({
+    template: ProjectTemplateSchema,
+});
+export const DeleteProjectTemplateOptionsSchema = z.object({
+    id: z.string().min(1),
+});
+export const DeleteProjectTemplateResponseSchema = z.object({
+    deleted: z.boolean(),
+});
+export const ReorderProjectTemplatesOptionsSchema = z.object({
+    orders: z
+        .array(z.object({ id: z.string().min(1), order: z.number().int() }))
+        .min(1),
+});
+export const ReorderProjectTemplatesResponseSchema = z.object({
+    updatedIds: z.array(z.string()),
+});
+/**
+ * `id` is omitted when a built-in (non-Firestore-backed) template becomes the
+ * org default, so this just needs to clear `isDefault` on the owner's stored
+ * templates without pointing it at a new one.
+ */
+export const SetDefaultProjectTemplateOptionsSchema = z.object({
+    id: z.string().min(1).optional(),
+});
+export const SetDefaultProjectTemplateResponseSchema = z.object({
+    defaultId: z.string().nullable(),
+});

package/src/projects.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { AGENT_NATIVE_STARTER_REPO, getAgentNativeRootPackageJsonWriteError, getManagedDatabasePackageJsonError, getProjectState, GetShapeQuestionnaireOptionsSchema, InitialPromptSchema, isProjectDeleted, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, ProjectSettingsSchema, ProjectTemplateOverridesSchema, ShapeSessionSchema, SubmitShapeAnswersOptionsSchema, } from "./projects";
+import { AGENT_NATIVE_STARTER_REPO, getAgentNativeRootPackageJsonWriteError, getManagedDatabasePackageJsonError, getProjectState, GetShapeQuestionnaireOptionsSchema, InitialPromptSchema, isProjectDeleted, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, 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" });
@@ -55,9 +55,6 @@ describe("guided onboarding project settings", () => {
     };
     it("parses a snapshotted questionnaire session", () => {
         expect(ShapeSessionSchema.parse(shapeSession)).toEqual(shapeSession);
-        expect(ProjectSettingsSchema.parse({ shapeSession })).toEqual({
-            shapeSession,
-        });
     });
     it("requires a dated catalog version", () => {
         expect(() => ShapeSessionSchema.parse({

package/src/realtime.d.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 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_DELEGATED_MODEL: "gpt-6-luna";
+export declare const BUILDER_REALTIME_DELEGATED_MODEL_LEGACY: "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<{
@@ -153,7 +154,7 @@ export declare const OpenAILiveSessionConfigSchema: z.ZodObject<{
     delegation: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"responses">;
         responses: z.ZodObject<{
-            model: z.ZodLiteral<"gpt-5.6-luna">;
+            model: z.ZodUnion<readonly [z.ZodLiteral<"gpt-6-luna">, 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">;
@@ -212,7 +213,7 @@ export declare const BuilderRealtimeSessionRequestSchema: z.ZodObject<{
         delegation: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodLiteral<"responses">;
             responses: z.ZodObject<{
-                model: z.ZodLiteral<"gpt-5.6-luna">;
+                model: z.ZodUnion<readonly [z.ZodLiteral<"gpt-6-luna">, 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">;

package/src/realtime.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 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_DELEGATED_MODEL = "gpt-6-luna";
+export const BUILDER_REALTIME_DELEGATED_MODEL_LEGACY = "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;
@@ -154,8 +155,16 @@ const OpenAILiveToolSchema = z.union([
     OpenAIRealtimeFunctionToolSchema,
     z.object({ type: z.literal("web_search") }),
 ]);
+const RealtimeDelegatedModelSchema = z
+    .union([
+    z.literal(BUILDER_REALTIME_DELEGATED_MODEL),
+    z.literal(BUILDER_REALTIME_DELEGATED_MODEL_LEGACY),
+])
+    .overwrite((model) => model === BUILDER_REALTIME_DELEGATED_MODEL_LEGACY
+    ? BUILDER_REALTIME_DELEGATED_MODEL
+    : model);
 const OpenAILiveResponsesDelegationSchema = z.object({
-    model: z.literal(BUILDER_REALTIME_DELEGATED_MODEL),
+    model: RealtimeDelegatedModelSchema,
     instructions: z.string().max(32000).optional(),
     tools: z.array(OpenAILiveToolSchema).max(32).optional(),
     tool_choice: z

package/src/realtime.spec.js

@@ -17,7 +17,7 @@ describe("BuilderRealtimeSessionRequestSchema", () => {
                 delegation: {
                     type: "responses",
                     responses: {
-                        model: "gpt-5.6-luna",
+                        model: "gpt-6-luna",
                         tools: [
                             {
                                 type: "function",
@@ -32,12 +32,25 @@ describe("BuilderRealtimeSessionRequestSchema", () => {
             },
         });
         expect(result.session).toMatchObject({
+            model: "gpt-live-1",
+            delegation: {
+                type: "responses",
+                responses: { model: "gpt-6-luna" },
+            },
+        });
+    });
+    it("normalizes the legacy delegated model name", () => {
+        const result = OpenAILiveSessionConfigSchema.parse({
             model: "gpt-live-1",
             delegation: {
                 type: "responses",
                 responses: { model: "gpt-5.6-luna" },
             },
         });
+        expect(result.delegation).toEqual({
+            type: "responses",
+            responses: { model: "gpt-6-luna" },
+        });
     });
     it("accepts a bounded audio session with tools", () => {
         var _a;

package/src/repo-indexing.d.ts

@@ -149,6 +149,10 @@ export interface DesignSystem {
      * have no code to detect from, and whenever the agent couldn't tell.
      */
     framework?: DesignSystemFramework;
+    /**
+     * @deprecated Prefer checking DisplayDesignSystem.docCount instead of relying on
+     * "in-progress" or "completed".
+     */
     status: "in-progress" | "completed" | "failed";
     scope: DesignSystemScope;
     deprecated: boolean;

package/src/system-one.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const SYSTEM_ONE_DEFAULT_MODEL = "jev-latest";
+export declare const SystemOneAvailabilityResponseSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type SystemOneAvailabilityResponse = z.infer<typeof SystemOneAvailabilityResponseSchema>;
+export declare const SystemOneRequestSchema: z.ZodObject<{
+    state: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>;
+    model: z.ZodDefault<z.ZodString>;
+    questions: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"noul">;
+        instructions: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>;
+        criteria: z.ZodOptional<z.ZodObject<{
+            true: z.ZodOptional<z.ZodString>;
+            false: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        instructions: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>;
+        criteria: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"score">;
+        instructions: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>]>;
+        criteria: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>], "type">>;
+}, z.core.$loose>;
+export declare const SystemOneResponseSchema: z.ZodObject<{
+    model: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"noul">;
+        noul: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        choice: z.ZodString;
+        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        confidence: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"score">;
+        score: z.ZodNumber;
+        legend: z.ZodRecord<z.ZodString, z.ZodString>;
+        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        confidence: z.ZodNumber;
+    }, z.core.$loose>], "type">>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$loose>;
+export type SystemOneRequest = z.output<typeof SystemOneRequestSchema>;
+export type SystemOneResponse = z.infer<typeof SystemOneResponseSchema>;

package/src/system-one.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export const SYSTEM_ONE_DEFAULT_MODEL = "jev-latest";
+export const SystemOneAvailabilityResponseSchema = z
+    .object({
+    enabled: z.boolean(),
+})
+    .meta({
+    description: "Response for GET /agent-native/jev/v1/status.",
+});
+const SystemOneValueSchema = z.union([
+    z.string(),
+    z.record(z.string(), z.unknown()),
+    z.array(z.unknown()),
+]);
+const NoulQuestionSchema = z
+    .object({
+    type: z.literal("noul"),
+    instructions: SystemOneValueSchema,
+    criteria: z
+        .object({
+        true: z.string().optional(),
+        false: z.string().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const ChoiceQuestionSchema = z
+    .object({
+    type: z.literal("choice"),
+    instructions: SystemOneValueSchema,
+    criteria: z
+        .record(z.string(), z.string().nullable())
+        .refine((criteria) => Object.keys(criteria).length > 0, {
+        message: "At least one choice is required.",
+    }),
+})
+    .passthrough();
+const ScoreQuestionSchema = z
+    .object({
+    type: z.literal("score"),
+    instructions: SystemOneValueSchema,
+    criteria: z.array(z.string()).min(2),
+})
+    .passthrough();
+const SystemOneQuestionSchema = z.discriminatedUnion("type", [
+    NoulQuestionSchema,
+    ChoiceQuestionSchema,
+    ScoreQuestionSchema,
+]);
+export const SystemOneRequestSchema = z
+    .object({
+    state: SystemOneValueSchema,
+    model: z.string().trim().min(1).default(SYSTEM_ONE_DEFAULT_MODEL),
+    questions: z
+        .record(z.string().min(1), SystemOneQuestionSchema)
+        .refine((questions) => Object.keys(questions).length > 0, {
+        message: "At least one question is required.",
+    }),
+})
+    .passthrough()
+    .meta({
+    description: "Request body for POST /agent-native/jev/v1/system-one.",
+});
+const ProbabilitySchema = z.number().finite().min(0).max(1);
+const NoulAnswerSchema = z
+    .object({
+    type: z.literal("noul"),
+    noul: ProbabilitySchema,
+})
+    .passthrough();
+const ChoiceAnswerSchema = z
+    .object({
+    type: z.literal("choice"),
+    choice: z.string(),
+    probabilities: z.record(z.string(), ProbabilitySchema),
+    confidence: ProbabilitySchema,
+})
+    .passthrough();
+const ScoreAnswerSchema = z
+    .object({
+    type: z.literal("score"),
+    score: z.number().finite(),
+    legend: z.record(z.string(), z.string()),
+    probabilities: z.record(z.string(), ProbabilitySchema),
+    confidence: ProbabilitySchema,
+})
+    .passthrough();
+const SystemOneAnswerSchema = z.discriminatedUnion("type", [
+    NoulAnswerSchema,
+    ChoiceAnswerSchema,
+    ScoreAnswerSchema,
+]);
+export const SystemOneResponseSchema = z
+    .object({
+    model: z.string(),
+    answers: z.record(z.string(), SystemOneAnswerSchema),
+    usage: z.object({
+        input_tokens: z.number().int().nonnegative(),
+        output_tokens: z.number().int().nonnegative(),
+    }),
+})
+    .passthrough();

package/src/system-one.spec.d.ts

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

package/src/system-one.spec.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { SYSTEM_ONE_DEFAULT_MODEL, SystemOneAvailabilityResponseSchema, SystemOneRequestSchema, SystemOneResponseSchema, } from "./system-one";
+describe("System One schemas", () => {
+    it("validates Builder availability responses", () => {
+        expect(SystemOneAvailabilityResponseSchema.parse({ enabled: true })).toEqual({ enabled: true });
+        expect(() => SystemOneAvailabilityResponseSchema.parse({ enabled: "true" })).toThrow();
+    });
+    it("defaults the model and validates each question type", () => {
+        const request = SystemOneRequestSchema.parse({
+            state: { ticket: "export failed" },
+            questions: {
+                urgent: {
+                    type: "noul",
+                    instructions: "Is this urgent?",
+                },
+                team: {
+                    type: "choice",
+                    instructions: "Who owns this?",
+                    criteria: { support: "Customer issue", engineering: null },
+                },
+                severity: {
+                    type: "score",
+                    instructions: "How severe is this?",
+                    criteria: ["low", "high"],
+                },
+            },
+        });
+        expect(request.model).toBe(SYSTEM_ONE_DEFAULT_MODEL);
+    });
+    it("rejects a score question without two levels", () => {
+        expect(() => SystemOneRequestSchema.parse({
+            state: "ticket",
+            questions: {
+                severity: {
+                    type: "score",
+                    instructions: "How severe?",
+                    criteria: ["low"],
+                },
+            },
+        })).toThrow();
+    });
+    it("validates the structured response", () => {
+        expect(SystemOneResponseSchema.parse({
+            model: "jev-1.13.0",
+            answers: {
+                urgent: { type: "noul", noul: 0.8 },
+            },
+            usage: { input_tokens: 10, output_tokens: 2 },
+        }).usage.input_tokens).toBe(10);
+    });
+});