@builder.io/ai-utils 0.101.0 → 0.105.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.101.0",
+  "version": "0.105.0",
   "description": "Builder.io AI utils",
   "files": [
     "src"

package/src/codegen.d.ts

@@ -2317,6 +2317,7 @@ export declare const PublishAgentMessageRequestSchema: z.ZodObject<{
         tag: z.ZodOptional<z.ZodString>;
         ephemeral: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>]>>>;
+    requireConfirmation: z.ZodOptional<z.ZodBoolean>;
     skippedMCPs: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type PublishAgentMessageRequest = z.infer<typeof PublishAgentMessageRequestSchema>;
@@ -4324,6 +4325,12 @@ export interface WorkspaceFolder {
     templateRepoUrl?: string;
     repoName?: string;
     resetGit?: boolean;
+    /**
+     * The project's configured base/default branch (e.g. "main", "master"),
+     * distinct from `branchName` (the feature branch this folder checks out).
+     * Used when seeding or checking the base branch on the real remote.
+     */
+    mainBranchName?: string;
     branchName?: string;
     backupMetadata?: BackupMetadata;
     initializationCommand?: string;
@@ -4542,6 +4549,11 @@ export interface FusionConfig {
     /** If true, nuke and re-clone the git repo during init, overwriting the existing repo */
     rebuildGit?: boolean;
     mode?: Mode;
+    /**
+     * Combines with the backup modes: try to repair a corrupt git object database
+     * before backing up, instead of failing on the first unreadable object.
+     */
+    attemptCorruptGitRecovery?: boolean;
     autoDetectDevServer?: boolean;
     autoDetectDevServerPatterns?: string[];
     /**
@@ -4670,7 +4682,7 @@ export interface LoadHistoryResult {
     updatedUnixTime: number;
     turns: CodegenTurn[];
 }
-export type InitStateStep = "initial" | "init" | "validation" | "check-directories" | "create-directories" | "configure-git-repos" | "check-existing-git" | "update-remote-url" | "clone-repo" | "apply-partial-backup" | "configure-git-user" | "stash-changes" | "collect-repo-info" | "init-success" | "init-command" | "init-failed" | "snapshot-git-sync" | "snapshot-backup-restore";
+export type InitStateStep = "initial" | "init" | "validation" | "check-directories" | "create-directories" | "configure-git-repos" | "check-existing-git" | "update-remote-url" | "clone-repo" | "apply-partial-backup" | "configure-git-user" | "stash-changes" | "collect-repo-info" | "init-success" | "init-command" | "init-failed" | "snapshot-git-sync" | "snapshot-backup-restore" | "git-corruption-recovery" | "seed-base-branch";
 export interface InitStatusLog {
     id: number;
     timestamp: string;
@@ -5125,6 +5137,35 @@ export type MessageUpdateOptions = {
     type: "delete";
     idempotencyKey: string;
 };
+/**
+ * Args for the `writeFile` launch-server RPC.
+ *
+ * A named-args object because the RPC applies arguments by position and the
+ * container's pinned `dev-tools` rarely matches the caller's, so new fields
+ * have to be additive rather than order-sensitive.
+ */
+export interface WriteFileOptions {
+    /** Workspace-relative, e.g. `docs/NOTES.md`. */
+    path: string;
+    contents: string;
+}
+/**
+ * Discriminated rather than a nullable path, so a caller that gates behaviour
+ * on the write can tell a refusal from a write that never happened, instead of
+ * reading `null` as both.
+ *
+ * Gate on `success`, not on parsing `error`. Only an ACL denial is reported
+ * distinctly; a blocked `package.json`, a path outside the workspace and a
+ * filesystem error all share one generic message, their reason reaching only
+ * Sentry.
+ */
+export type WriteFileResult = {
+    success: true;
+    path: string;
+} | {
+    success: false;
+    error: string;
+};
 export interface LaunchInitializeSessionOptions {
     sessionId?: string;
     customInstructions?: CustomInstruction[];

package/src/codegen.js

@@ -1818,6 +1818,9 @@ export const PublishAgentMessageRequestSchema = z
     attachments: z.array(AttachmentSchema).optional(),
     toolResults: z.array(ContentMessageItemToolResultSchema).optional(),
     systemReminders: z.array(SystemReminderSchema).optional(),
+    requireConfirmation: z.boolean().optional().meta({
+        description: "Ask before high-impact MCP tool calls; the turn emits confirmation_required and waits.",
+    }),
     skippedMCPs: z.array(z.string()).optional().meta({
         description: "Per-message denylist of MCP server ids to skip, e.g. a 'disable for this session' UI toggle.",
     }),

package/src/design-systems.d.ts

@@ -266,3 +266,13 @@ export declare const listPublicSourceFilesQuerySchema: z.ZodObject<{
     ref: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ListPublicSourceFilesQuery = z.infer<typeof listPublicSourceFilesQuerySchema>;
+export type DSITier = "free" | "pro" | "team" | "enterprise";
+export interface DSITierLimitResponse {
+    tier: DSITier;
+    /** Whether this org can index via the web (Figma/.md) flow at its tier. */
+    enabled: boolean;
+    /** Every active design system the org has, regardless of how it was created. */
+    current: number;
+    /** `null` is unlimited. */
+    max: number | null;
+}

package/src/events.d.ts

@@ -16,6 +16,7 @@ export interface AssistantCompletionResultEvent {
     resolveId?: string;
 }
 export interface AssistantError {
+    code?: string;
     message: string;
     status?: number;
     actions?: AssistantMessageAction[];

package/src/index.d.ts

@@ -23,4 +23,6 @@ export * from "./design-systems.js";
 export * from "./editor-ai.js";
 export * from "./realtime.js";
 export * from "./embeddings.js";
+export * from "./system-one.js";
+export * from "./mcp-servers.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/index.js

@@ -23,4 +23,6 @@ export * from "./design-systems.js";
 export * from "./editor-ai.js";
 export * from "./realtime.js";
 export * from "./embeddings.js";
+export * from "./system-one.js";
+export * from "./mcp-servers.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/mcp-servers.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare const McpServerRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    ownerId: z.ZodString;
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    clientName: z.ZodOptional<z.ZodString>;
+    createDate: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+    tokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    requiresOAuth: z.ZodOptional<z.ZodBoolean>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    isBuiltinConfiguration: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type McpServerRecord = z.infer<typeof McpServerRecordSchema>;
+export declare const McpServersListResponseSchema: z.ZodObject<{
+    servers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ownerId: z.ZodString;
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        clientName: z.ZodOptional<z.ZodString>;
+        createDate: z.ZodNumber;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        tokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        requiresOAuth: z.ZodOptional<z.ZodBoolean>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        isBuiltinConfiguration: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type McpServersListResponse = z.infer<typeof McpServersListResponseSchema>;
+export declare const McpServersDeleteRequestSchema: z.ZodObject<{
+    serverIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    serverUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type McpServersDeleteRequest = z.infer<typeof McpServersDeleteRequestSchema>;
+export declare const McpServersDeleteResponseSchema: z.ZodObject<{
+    deletedServerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type McpServersDeleteResponse = z.infer<typeof McpServersDeleteResponseSchema>;
+export declare const McpServersDisableRequestSchema: z.ZodObject<{
+    serverIds: z.ZodArray<z.ZodString>;
+    disabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type McpServersDisableRequest = z.infer<typeof McpServersDisableRequestSchema>;
+export declare const McpServersDisableResponseSchema: z.ZodObject<{
+    updatedServerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type McpServersDisableResponse = z.infer<typeof McpServersDisableResponseSchema>;

package/src/mcp-servers.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+// Deliberately excludes authorizationToken, refreshToken, tokenType, and oauthMetadata:
+// this is a general-purpose management API any org member can call, so credentials
+// that could be replayed against the third-party server never leave the backend.
+export const McpServerRecordSchema = z
+    .object({
+    id: z.string(),
+    ownerId: z.string(),
+    type: z.literal("url"),
+    url: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    provider: z.string().optional(),
+    clientName: z.string().optional(),
+    createDate: z.number(),
+    updatedAt: z.number().optional(),
+    tokenExpiresAt: z.number().nullish(),
+    requiresOAuth: z.boolean().optional(),
+    disabled: z.boolean().optional(),
+    isBuiltinConfiguration: z.boolean().optional(),
+})
+    .meta({ title: "McpServerRecord" });
+export const McpServersListResponseSchema = z
+    .object({
+    servers: z.array(McpServerRecordSchema),
+})
+    .meta({ title: "McpServersListResponse" });
+// `serverUrl` mirrors the legacy disconnect-by-url Firestore query.
+export const McpServersDeleteRequestSchema = z
+    .object({
+    serverIds: z.array(z.string()).optional(),
+    serverUrl: z.string().optional(),
+})
+    .meta({ title: "McpServersDeleteRequest" });
+export const McpServersDeleteResponseSchema = z
+    .object({
+    deletedServerIds: z.array(z.string()),
+})
+    .meta({ title: "McpServersDeleteResponse" });
+export const McpServersDisableRequestSchema = z
+    .object({
+    serverIds: z.array(z.string()).min(1),
+    disabled: z.boolean(),
+})
+    .meta({ title: "McpServersDisableRequest" });
+export const McpServersDisableResponseSchema = z
+    .object({
+    updatedServerIds: z.array(z.string()),
+})
+    .meta({ title: "McpServersDisableResponse" });

package/src/projects.d.ts

@@ -334,6 +334,23 @@ export interface CodegenSetLastCommit {
     lastCommitHash: GitSnapshot;
     clearSecondaryVolumeId: boolean;
 }
+/**
+ * A run that ended on an unreadable git object database.
+ *
+ * Reported by the container rather than inferred by the service: a backup-mode
+ * launch is only ever observed as a machine that started and exited, so from
+ * the outside a corrupt repo and a clean backup look the same.
+ */
+export declare const GitCorruptionReportSchema: z.ZodObject<{
+    at: z.ZodNumber;
+    error: z.ZodString;
+    repoPath: z.ZodOptional<z.ZodString>;
+    emptyObjects: z.ZodOptional<z.ZodNumber>;
+    recoveryAttempted: z.ZodOptional<z.ZodBoolean>;
+    recoveryRefetched: z.ZodOptional<z.ZodBoolean>;
+    devToolsVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GitCorruptionReport = z.infer<typeof GitCorruptionReportSchema>;
 export interface CodegenRuntimeStatus {
     projectId: string;
     branchName: string;
@@ -341,6 +358,7 @@ export interface CodegenRuntimeStatus {
     clearSecondaryVolumeId?: boolean;
     lastServerState?: LaunchServerState;
     lastServerVersion?: string;
+    gitCorruption?: GitCorruptionReport;
 }
 export interface BackupGitRepoResultValid {
     success: true;
@@ -587,6 +605,12 @@ export interface BranchSharedData {
     lastServerState?: LaunchServerState | null;
     lastServerStateDate?: number | null;
     lastServerVersion?: string | null;
+    /**
+     * Last run that died on a corrupt git object database, cleared the next time
+     * the branch initializes cleanly. A volume in this state can never produce a
+     * deletion-safe backup, so the cleanup cron will never reclaim it.
+     */
+    gitCorruption?: GitCorruptionReport | null;
     name?: string;
     hidden?: boolean;
     createdBy?: string;
@@ -2413,6 +2437,9 @@ export interface MemorySummary extends Pick<MemoryData, (typeof MEMORY_SUMMARY_F
 export interface GetProjectMemoriesResult {
     memories: MemorySummary[];
 }
+export interface GetFusionPrivateKeyResult {
+    id: string;
+}
 interface BaseSendMessageMessage {
 }
 export interface ValidatingBranchMessage extends BaseSendMessageMessage {
@@ -3417,6 +3444,14 @@ export declare const ReserveSlugResponseSchema: z.ZodObject<{
     slug: z.ZodString;
 }, z.core.$strip>;
 export type ReserveSlugResponse = z.infer<typeof ReserveSlugResponseSchema>;
+export declare const CheckOrgSuffixAvailableRequestSchema: z.ZodObject<{
+    suffix: z.ZodString;
+}, z.core.$strip>;
+export type CheckOrgSuffixAvailableRequest = z.infer<typeof CheckOrgSuffixAvailableRequestSchema>;
+export declare const CheckOrgSuffixAvailableResponseSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+}, z.core.$strip>;
+export type CheckOrgSuffixAvailableResponse = z.infer<typeof CheckOrgSuffixAvailableResponseSchema>;
 export declare const GoldenSnapshotRefreshRequestSchema: z.ZodObject<{
     sourceCommitSha: z.ZodString;
 }, z.core.$strict>;

package/src/projects.js

@@ -107,6 +107,23 @@ export const EXAMPLE_OR_STARTER_REPOS = [
     AGENT_NATIVE_STARTER_REPO,
 ];
 export const EXAMPLE_OR_STARTER_REPOS_URLS = EXAMPLE_OR_STARTER_REPOS.map((repo) => `https://github.com/${repo}`);
+/**
+ * A run that ended on an unreadable git object database.
+ *
+ * Reported by the container rather than inferred by the service: a backup-mode
+ * launch is only ever observed as a machine that started and exited, so from
+ * the outside a corrupt repo and a clean backup look the same.
+ */
+export const GitCorruptionReportSchema = z.object({
+    /** When the run failed — not when the objects were damaged. */
+    at: z.number(),
+    error: z.string().max(2000),
+    repoPath: z.string().max(500).optional(),
+    emptyObjects: z.number().int().nonnegative().max(1000000).optional(),
+    recoveryAttempted: z.boolean().optional(),
+    recoveryRefetched: z.boolean().optional(),
+    devToolsVersion: z.string().max(100).optional(),
+});
 /** Fields shared by every {@link ProjectSkill} variant. */
 const ProjectSkillBaseShape = {
     key: z.string().meta({
@@ -1787,6 +1804,12 @@ export const ReserveSlugRequestSchema = z.object({
 export const ReserveSlugResponseSchema = z.object({
     slug: z.string(),
 });
+export const CheckOrgSuffixAvailableRequestSchema = z.object({
+    suffix: z.string().min(1),
+});
+export const CheckOrgSuffixAvailableResponseSchema = z.object({
+    available: z.boolean(),
+});
 const gitCommitHashSchema = z
     .string()
     .regex(/^[0-9a-f]{7,40}$/i, "Must be a valid git commit hash (7–40 hex chars)");

package/src/system-one.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const SYSTEM_ONE_DEFAULT_MODEL = "jev-latest";
+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,95 @@
+import { z } from "zod";
+export const SYSTEM_ONE_DEFAULT_MODEL = "jev-latest";
+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,47 @@
+import { describe, expect, it } from "vitest";
+import { SYSTEM_ONE_DEFAULT_MODEL, SystemOneRequestSchema, SystemOneResponseSchema, } from "./system-one";
+describe("System One schemas", () => {
+    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);
+    });
+});