@builder.io/ai-utils 0.72.0 → 0.73.0

package/package.json

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

package/src/codegen.d.ts

@@ -3560,12 +3560,10 @@ export interface UserInput {
     /** @deprecated */
     repair?: boolean;
 }
-export interface CodegenTurn {
-    state: "running" | "done" | "error";
+interface CodegenTurnBase {
     unixTime: number;
     completionId: string;
     title: string;
-    nextUrl: string | undefined;
     user: UserSource;
     creditsUsed: number;
     actions: ActionItem[];
@@ -3577,7 +3575,34 @@ export interface CodegenTurn {
     lastCommit: GitSnapshot | undefined;
     cachedToolResults?: ContentMessageItemToolResult[];
     autoContinue: boolean;
+    /**
+     * Only set on synthetic per-user-message checkpoints (the non-linear
+     * `getSessionTurns` result). `completionId` always stays the checkpoint's
+     * own identity — for these synthetic turns, the user message's id — which is
+     * exactly what restoring "before this point" needs (the factual commit at
+     * that moment). `finalCompletionId` separately carries the last agent turn in
+     * the message's range that holds the post-message commit (`afterCommit`), for
+     * callers that want to restore to the "after" state. Undefined for ordinary
+     * (linear) turns.
+     */
+    finalCompletionId?: string;
+}
+/**
+ * A completed turn. Invariant: a `done` turn ALWAYS has a `nextUrl` (the
+ * continuation pointer the server emits on the `done` event / persists as the
+ * session's last completion). Encoded in the type so `state === "done"` narrows
+ * `nextUrl` to `string` — restore/anchor logic can rely on it.
+ */
+export interface CodegenTurnDone extends CodegenTurnBase {
+    state: "done";
+    nextUrl: string;
+}
+/** A turn that is still running, or errored before completing. */
+export interface CodegenTurnPending extends CodegenTurnBase {
+    state: "running" | "error";
+    nextUrl: string | undefined;
 }
+export type CodegenTurn = CodegenTurnDone | CodegenTurnPending;
 export interface GetSessionTurnsResult {
     turns: CodegenTurn[];
     allIds: string[];
@@ -4656,3 +4681,4 @@ export interface SessionData {
     numNormalUserMessages: number;
     metadata?: Record<string, any>;
 }
+export {};

package/src/design-systems.d.ts

@@ -35,10 +35,6 @@ export interface GenerateDesignSystemFormFields {
  */
 export declare const GITHUB_REPO_URL_REGEX: RegExp;
 export interface GenerateDesignSystemRequest extends GenerateDesignSystemFormFields {
-    /**
-     * Mixed list of uploaded files in any order. Sent as repeated
-     * `attachments` fields in the multipart body.
-     */
     attachments: File[];
 }
 export interface GenerateDesignSystemResponse {
@@ -58,18 +54,75 @@ export interface GenerateDesignSystemErrorResponse {
 export declare const GENERATE_DESIGN_SYSTEM_MAX_FILE_BYTES: number;
 export declare const GENERATE_DESIGN_SYSTEM_MAX_ATTACHMENTS = 50;
 export declare const GENERATE_DESIGN_SYSTEM_MIN_ATTACHMENTS = 1;
+export declare const generateDesignSystemBodySchema: z.ZodObject<{
+    projectName: z.ZodOptional<z.ZodString>;
+    devToolsVersion: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+    githubRepoUrl: z.ZodOptional<z.ZodString>;
+    connectedProjectId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GenerateDesignSystemBody = z.infer<typeof generateDesignSystemBodySchema>;
 /**
- * Validation for non-file fields posted alongside the multipart upload.
- * Files are parsed out of the body by multer before this schema runs.
+ * Signed-URL upload flow.
  *
- * The inferred type matches `GenerateDesignSystemFormFields` so the wire
- * contract stays in lockstep with the shared type.
+ * Clients no longer post `.fig` bytes through the service (Cloud Run caps
+ * request bodies at 32 MiB). Instead they call `upload/start` to get a
+ * temporary signed resumable-upload URL per attachment, stream the bytes
+ * directly to GCS, then call `/generate` with the returned upload tokens.
+ * See `tech-specs/signed-url-figma-upload`.
  */
-export declare const generateDesignSystemBodySchema: z.ZodObject<{
+/** A single attachment the client declares when starting an upload. */
+export declare const uploadStartAttachmentSchema: z.ZodObject<{
+    name: z.ZodString;
+    mimetype: z.ZodString;
+    declaredSize: z.ZodNumber;
+}, z.core.$strip>;
+export type UploadStartAttachment = z.infer<typeof uploadStartAttachmentSchema>;
+/** Request body for `POST /design-systems/v1/upload/start`. */
+export declare const uploadStartBodySchema: z.ZodObject<{
+    attachments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        mimetype: z.ZodString;
+        declaredSize: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UploadStartBody = z.infer<typeof uploadStartBodySchema>;
+/**
+ * Claims encoded inside a signed `uploadToken`. Bound to the GCS object at
+ * `upload/start` and verified at `/generate`, so a client cannot point the
+ * decode worker at an object it did not upload.
+ */
+export declare const uploadTokenPayloadSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    gcsObject: z.ZodString;
+    ownerId: z.ZodString;
+    mimetype: z.ZodString;
+    originalName: z.ZodString;
+    idx: z.ZodNumber;
+}, z.core.$strip>;
+export type UploadTokenPayload = z.infer<typeof uploadTokenPayloadSchema>;
+export interface UploadStartResponseItem {
+    idx: number;
+    /** Signed URL the client POSTs to (with `x-goog-resumable: start`) to begin the resumable upload. */
+    uploadUrl: string;
+    /** Opaque signed token the client passes back to `/generate`. */
+    uploadToken: string;
+}
+export interface UploadStartResponse {
+    jobId: string;
+    uploads: UploadStartResponseItem[];
+}
+/**
+ * Request body for the signed-URL variant of `POST /design-systems/v1/generate`.
+ * Same non-file fields as the legacy multipart form, plus the `uploads`
+ * tokens returned by `upload/start` (one per attachment).
+ */
+export declare const generateDesignSystemRequestSchema: z.ZodObject<{
     projectName: z.ZodOptional<z.ZodString>;
     devToolsVersion: z.ZodOptional<z.ZodString>;
     selection: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
     githubRepoUrl: z.ZodOptional<z.ZodString>;
     connectedProjectId: z.ZodOptional<z.ZodString>;
+    uploads: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
-export type GenerateDesignSystemBody = z.infer<typeof generateDesignSystemBodySchema>;
+export type GenerateDesignSystemRequestBody = z.infer<typeof generateDesignSystemRequestSchema>;

package/src/design-systems.js

@@ -8,13 +8,6 @@ export const GITHUB_REPO_URL_REGEX = /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[
 export const GENERATE_DESIGN_SYSTEM_MAX_FILE_BYTES = 2 * 1024 * 1024 * 1024;
 export const GENERATE_DESIGN_SYSTEM_MAX_ATTACHMENTS = 50;
 export const GENERATE_DESIGN_SYSTEM_MIN_ATTACHMENTS = 1;
-/**
- * Validation for non-file fields posted alongside the multipart upload.
- * Files are parsed out of the body by multer before this schema runs.
- *
- * The inferred type matches `GenerateDesignSystemFormFields` so the wire
- * contract stays in lockstep with the shared type.
- */
 export const generateDesignSystemBodySchema = z.object({
     projectName: z.string().trim().min(1).max(200).optional(),
     devToolsVersion: z.string().trim().min(1).max(64).optional(),
@@ -40,3 +33,54 @@ export const generateDesignSystemBodySchema = z.object({
         .optional(),
     connectedProjectId: z.string().trim().min(1).max(128).optional(),
 });
+/**
+ * Signed-URL upload flow.
+ *
+ * Clients no longer post `.fig` bytes through the service (Cloud Run caps
+ * request bodies at 32 MiB). Instead they call `upload/start` to get a
+ * temporary signed resumable-upload URL per attachment, stream the bytes
+ * directly to GCS, then call `/generate` with the returned upload tokens.
+ * See `tech-specs/signed-url-figma-upload`.
+ */
+/** A single attachment the client declares when starting an upload. */
+export const uploadStartAttachmentSchema = z.object({
+    name: z.string().trim().min(1).max(512),
+    mimetype: z.string().trim().min(1).max(255),
+    declaredSize: z
+        .number()
+        .int()
+        .positive()
+        .max(GENERATE_DESIGN_SYSTEM_MAX_FILE_BYTES),
+});
+/** Request body for `POST /design-systems/v1/upload/start`. */
+export const uploadStartBodySchema = z.object({
+    attachments: z
+        .array(uploadStartAttachmentSchema)
+        .min(GENERATE_DESIGN_SYSTEM_MIN_ATTACHMENTS)
+        .max(GENERATE_DESIGN_SYSTEM_MAX_ATTACHMENTS),
+});
+/**
+ * Claims encoded inside a signed `uploadToken`. Bound to the GCS object at
+ * `upload/start` and verified at `/generate`, so a client cannot point the
+ * decode worker at an object it did not upload.
+ */
+export const uploadTokenPayloadSchema = z.object({
+    jobId: z.string().min(1),
+    gcsObject: z.string().min(1),
+    ownerId: z.string().min(1),
+    mimetype: z.string().min(1),
+    originalName: z.string().min(1),
+    idx: z.number().int().nonnegative(),
+});
+/**
+ * Request body for the signed-URL variant of `POST /design-systems/v1/generate`.
+ * Same non-file fields as the legacy multipart form, plus the `uploads`
+ * tokens returned by `upload/start` (one per attachment).
+ */
+export const generateDesignSystemRequestSchema = z.object({
+    ...generateDesignSystemBodySchema.shape,
+    uploads: z
+        .array(z.string().min(1))
+        .min(GENERATE_DESIGN_SYSTEM_MIN_ATTACHMENTS)
+        .max(GENERATE_DESIGN_SYSTEM_MAX_ATTACHMENTS),
+});

package/src/events.d.ts

@@ -1039,6 +1039,8 @@ export type FigmaDecodeJobV1 = FusionEventVariant<"figma.decode.job", {
     projectId: string;
     projectName: string;
     figmaName: string;
+    /** Design-system record this job feeds; updated with the branch once created. */
+    designSystemId?: string;
     /**
      * GCS object paths (relative to the configured bucket) of every attachment
      * uploaded for this job. The worker streams these back down, runs