@clickraft/cli 0.8.7 → 0.8.9

package/dist/cli.js

@@ -10,10 +10,15 @@ import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
-import { request as undiciRequest } from "undici";
+import { z as z5 } from "zod";
 import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { request as undiciRequest } from "undici";
+import { z as z11 } from "zod";
 import { createHash, randomUUID } from "crypto";
-import { z as z5 } from "zod";
+import { z as z10 } from "zod";
 import { createHash as createHash2 } from "crypto";
 import { request as undiciRequest2 } from "undici";
 var TOKEN_FIELD_PATTERN = /"(access_token|refresh_token|device_code|user_code|code_verifier|client_secret)"\s*:\s*"[^"]*"/gi;
@@ -87,6 +92,165 @@ var TokenRowSchema = z4.object({
   createdAt: z4.string()
 }).strict();
 var TokensListResponseSchema = z4.array(TokenRowSchema);
+var DeclaredParamSchema = z5.object({
+  name: z5.string(),
+  type: z5.string(),
+  required: z5.boolean(),
+  defaultValue: z5.string().nullable().optional(),
+  enumValues: z5.array(z5.string()).nullable().optional(),
+  description: z5.string().nullable().optional()
+}).strict();
+var TemplateSummarySchema = z5.object({
+  id: z5.string().uuid(),
+  source: z5.enum(["own", "system"]),
+  name: z5.string(),
+  description: z5.string().nullable(),
+  category: z5.string().nullable(),
+  thumbnailUrl: z5.string().nullable(),
+  tags: z5.array(z5.string()),
+  createdAt: z5.string()
+}).strict();
+var TemplateDetailSchema = TemplateSummarySchema.extend({
+  declaredParams: z5.array(DeclaredParamSchema),
+  timesUsed: z5.number()
+}).strict();
+var TemplatesListResponseSchema = z5.object({
+  templates: z5.array(TemplateSummarySchema),
+  cursor: z5.string().nullable(),
+  hasMore: z5.boolean()
+}).strict();
+var ProductReferenceSchema = z6.object({
+  id: z6.string().uuid(),
+  imageId: z6.string().uuid().optional()
+}).strict();
+var GenerateCreateRequestSchema = z6.object({
+  modelSlug: z6.string().min(1).max(100),
+  input: z6.object({
+    prompt: z6.string().max(1e4).optional(),
+    referenceImageUrl: z6.string().url().optional(),
+    referenceImages: z6.array(z6.string().url()).max(8).optional(),
+    aspectRatio: z6.string().regex(/^\d+:\d+$/).optional(),
+    resolution: z6.string().regex(/^\d+x\d+$/).optional(),
+    durationSeconds: z6.number().int().min(1).max(60).optional(),
+    providerParams: z6.record(z6.string(), z6.unknown()).optional()
+  }).strict(),
+  options: z6.object({
+    workflowId: z6.string().uuid().optional(),
+    nodeId: z6.string().optional()
+  }).strict().optional(),
+  products: z6.array(ProductReferenceSchema).min(1).max(10).optional()
+}).strict();
+var GenerateCreateResponseSchema = z6.object({
+  jobId: z6.string().uuid(),
+  status: z6.enum(["queued", "processing", "completed", "failed"]),
+  estimatedSeconds: z6.number().int().nonnegative().nullable(),
+  creditsCharged: z6.number().int().nonnegative()
+}).strict();
+var GenerationStatusSchema = z6.enum([
+  "queued",
+  "processing",
+  "uploading",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+var GenerationResultSchema = z6.object({
+  jobId: z6.string().uuid(),
+  status: GenerationStatusSchema,
+  modelSlug: z6.string(),
+  resultUrl: z6.string().url().nullable(),
+  thumbnailUrl: z6.string().url().nullable(),
+  errorCode: z6.string().nullable(),
+  errorMessage: z6.string().nullable(),
+  creditsCharged: z6.number().int().nonnegative(),
+  creditsRefunded: z6.boolean(),
+  startedAt: z6.string().nullable(),
+  completedAt: z6.string().nullable()
+}).strict();
+var MAX_UPLOAD_SIZE_BYTES = 15 * 1024 * 1024;
+var UploadRequestSchema = z7.object({
+  filename: z7.string().min(1).max(255),
+  contentType: z7.string().regex(/^[\w-]+\/[\w+.-]+$/),
+  sizeBytes: z7.number().int().positive().max(MAX_UPLOAD_SIZE_BYTES),
+  contentHash: z7.string().regex(/^sha256:[0-9a-f]{64}$/)
+}).strict();
+var UploadResponseSchema = z7.object({
+  assetId: z7.string().uuid(),
+  uploadUrl: z7.string().url(),
+  publicUrl: z7.string().url(),
+  deduplicated: z7.boolean()
+}).strict();
+var NodeTypeSummarySchema = z8.object({
+  type: z8.string(),
+  portCount: z8.number()
+}).strict();
+var NodeTypePortSchema = z8.object({
+  handleId: z8.string(),
+  direction: z8.enum(["input", "output"]),
+  dataType: z8.string()
+}).strict();
+var NodeTypeDetailSchema = z8.object({
+  type: z8.string(),
+  ports: z8.array(NodeTypePortSchema),
+  agentWritableFields: z8.array(z8.string())
+}).strict();
+var NodeTypesListResponseSchema = z8.object({
+  nodeTypes: z8.array(NodeTypeSummarySchema)
+}).strict();
+var WorkflowDeclaredParamSchema = z9.object({
+  name: z9.string(),
+  type: z9.string(),
+  required: z9.boolean().optional(),
+  defaultValue: z9.unknown().optional(),
+  description: z9.unknown().optional()
+}).passthrough();
+var WorkflowSummarySchema = z9.object({
+  id: z9.string().uuid(),
+  name: z9.string(),
+  tags: z9.array(z9.string()),
+  declared_params: z9.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z9.number().int().nonnegative(),
+  updated_at: z9.string()
+}).strict();
+var WorkflowsListResponseSchema = z9.object({
+  items: z9.array(WorkflowSummarySchema),
+  nextCursor: z9.string().nullable()
+}).strict();
+var WorkflowDetailSchema = z9.object({
+  id: z9.string().uuid(),
+  name: z9.string(),
+  description: z9.string().nullable(),
+  tags: z9.array(z9.string()),
+  declared_params: z9.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z9.number().int().nonnegative(),
+  nodes: z9.array(z9.unknown()),
+  edges: z9.array(z9.unknown()),
+  created_at: z9.string(),
+  updated_at: z9.string()
+}).strict();
+var WorkflowCreateResponseSchema = z9.object({
+  id: z9.string().uuid(),
+  name: z9.string(),
+  description: z9.string().nullable(),
+  tags: z9.array(z9.string()),
+  declared_params: z9.array(WorkflowDeclaredParamSchema).nullable().default([]),
+  canvas_rev: z9.number().int().nonnegative(),
+  created_at: z9.string(),
+  updated_at: z9.string()
+}).strict();
+var WorkflowMutateResponseSchema = z9.object({
+  canvas_rev: z9.number().int().nonnegative(),
+  applied: z9.number().int().nonnegative(),
+  workflow: WorkflowDetailSchema
+}).strict();
 var SERVER_ERROR_CODES = [
   "AUTH_TOKEN_MISSING",
   "AUTH_TOKEN_INVALID",
@@ -304,14 +468,14 @@ function signalToAbortError(signal) {
   err.name = "AbortError";
   return err;
 }
-var ServerSuccessSchema = (payload) => z5.object({ data: payload }).strict();
-var ServerErrorBodySchema = z5.object({
-  error: z5.object({
-    code: z5.string().min(1),
-    message: z5.string(),
-    correlationId: z5.string().optional(),
-    retryAfter: z5.number().int().nonnegative().optional(),
-    details: z5.unknown().optional()
+var ServerSuccessSchema = (payload) => z10.object({ data: payload }).strict();
+var ServerErrorBodySchema = z10.object({
+  error: z10.object({
+    code: z10.string().min(1),
+    message: z10.string(),
+    correlationId: z10.string().optional(),
+    retryAfter: z10.number().int().nonnegative().optional(),
+    details: z10.unknown().optional()
   }).strict()
 }).strict();
 var REDACT_BODY_LIMIT = 1024;
@@ -485,7 +649,7 @@ function parseSuccessBody(args) {
       err
     );
   }
-  const envelope = ServerSuccessSchema(args.responseSchema ?? z6.unknown()).safeParse(parsed);
+  const envelope = ServerSuccessSchema(args.responseSchema ?? z11.unknown()).safeParse(parsed);
   if (!envelope.success) {
     const issues = formatSchemaIssues(envelope.error);
     throw new ApiError(
@@ -813,6 +977,44 @@ function matchesPrefix(content, prefix) {
   }
   return true;
 }
+function waitForGeneration(params) {
+  return longPoll({
+    // Forward the iteration signal so the in-flight server hold is aborted as
+    // soon as the overall deadline expires — otherwise `--timeout 1` would still
+    // block for the full server long-poll round.
+    fetcher: (args) => params.client.request({
+      method: "GET",
+      path: `/jobs/${encodeURIComponent(params.jobId)}`,
+      query: { wait: params.serverWaitSeconds },
+      responseSchema: params.resultSchema,
+      signal: args?.signal
+    }),
+    isTerminal: params.isTerminal,
+    timeoutMs: params.timeoutMs,
+    signal: params.signal
+  });
+}
+async function createGeneration(params) {
+  const created = await params.client.request({
+    method: "POST",
+    path: "/jobs",
+    body: params.body,
+    responseSchema: params.createSchema,
+    signal: params.signal
+  });
+  if (!params.wait) {
+    return params.projectCreated(created, params.modelSlug);
+  }
+  return waitForGeneration({
+    client: params.client,
+    jobId: created.jobId,
+    timeoutMs: params.timeoutMs,
+    serverWaitSeconds: params.serverWaitSeconds,
+    signal: params.signal,
+    resultSchema: params.resultSchema,
+    isTerminal: params.isTerminal
+  });
+}
 
 // src/errors/codes.ts
 var LOGIN_HINT = "Run `clickraft login` to authenticate.";
@@ -1373,31 +1575,31 @@ function getCredentialsPath(ctx = {}) {
 }
 
 // src/auth/types.ts
-import { z as z7 } from "zod";
-var DeviceAuthorizationRequestSchema = z7.object({
-  client_id: z7.string(),
-  scope: z7.string()
+import { z as z12 } from "zod";
+var DeviceAuthorizationRequestSchema = z12.object({
+  client_id: z12.string(),
+  scope: z12.string()
 });
-var DeviceAuthorizationResponseSchema = z7.object({
-  device_code: z7.string(),
-  user_code: z7.string().min(1),
-  verification_uri: z7.string().url(),
-  verification_uri_complete: z7.string().url().optional(),
-  expires_in: z7.number().int().positive(),
-  interval: z7.number().int().positive().default(5)
+var DeviceAuthorizationResponseSchema = z12.object({
+  device_code: z12.string(),
+  user_code: z12.string().min(1),
+  verification_uri: z12.string().url(),
+  verification_uri_complete: z12.string().url().optional(),
+  expires_in: z12.number().int().positive(),
+  interval: z12.number().int().positive().default(5)
 });
-var DeviceTokenPollRequestSchema = z7.object({
-  client_id: z7.string(),
-  device_code: z7.string(),
-  grant_type: z7.literal("urn:ietf:params:oauth:grant-type:device_code")
+var DeviceTokenPollRequestSchema = z12.object({
+  client_id: z12.string(),
+  device_code: z12.string(),
+  grant_type: z12.literal("urn:ietf:params:oauth:grant-type:device_code")
 });
-var TokenResponseSchema = z7.object({
-  access_token: z7.string(),
-  token_type: z7.literal("Bearer"),
-  expires_in: z7.number().int().positive(),
-  scope: z7.string()
+var TokenResponseSchema = z12.object({
+  access_token: z12.string(),
+  token_type: z12.literal("Bearer"),
+  expires_in: z12.number().int().positive(),
+  scope: z12.string()
 });
-var DeviceTokenPollErrorCodeSchema = z7.enum([
+var DeviceTokenPollErrorCodeSchema = z12.enum([
   "authorization_pending",
   "slow_down",
   "access_denied",
@@ -1408,27 +1610,27 @@ var DeviceTokenPollErrorCodeSchema = z7.enum([
   "unsupported_grant_type",
   "invalid_scope"
 ]);
-var DeviceTokenPollErrorSchema = z7.object({
+var DeviceTokenPollErrorSchema = z12.object({
   error: DeviceTokenPollErrorCodeSchema,
-  error_description: z7.string().optional()
+  error_description: z12.string().optional()
 });
-var CredentialsProfileSchema = z7.object({
-  apiBaseUrl: z7.string().url(),
-  accessToken: z7.string(),
-  tokenType: z7.literal("Bearer"),
-  tokenPrefix: z7.string(),
-  organizationId: z7.string().uuid(),
-  organizationSlug: z7.string(),
-  userId: z7.string().uuid(),
-  scopes: z7.array(z7.string()),
-  expiresAt: z7.string().datetime(),
-  issuedAt: z7.string().datetime(),
-  clientId: z7.string()
+var CredentialsProfileSchema = z12.object({
+  apiBaseUrl: z12.string().url(),
+  accessToken: z12.string(),
+  tokenType: z12.literal("Bearer"),
+  tokenPrefix: z12.string(),
+  organizationId: z12.string().uuid(),
+  organizationSlug: z12.string(),
+  userId: z12.string().uuid(),
+  scopes: z12.array(z12.string()),
+  expiresAt: z12.string().datetime(),
+  issuedAt: z12.string().datetime(),
+  clientId: z12.string()
 }).strict();
-var CredentialsFileSchema = z7.object({
-  version: z7.literal(1),
-  defaultProfile: z7.string(),
-  profiles: z7.record(z7.string(), CredentialsProfileSchema)
+var CredentialsFileSchema = z12.object({
+  version: z12.literal(1),
+  defaultProfile: z12.string(),
+  profiles: z12.record(z12.string(), CredentialsProfileSchema)
 }).strict();
 
 // src/auth/credentials.ts
@@ -1711,87 +1913,10 @@ async function listBrandModels(options) {
   return data.brandModels;
 }
 
-// src/schemas/jobs.ts
-import { z as z9 } from "zod";
-var ProductReferenceSchema = z9.object({
-  id: z9.string().uuid(),
-  imageId: z9.string().uuid().optional()
-}).strict();
-var GenerateCreateRequestSchema = z9.object({
-  modelSlug: z9.string().min(1).max(100),
-  input: z9.object({
-    prompt: z9.string().max(1e4).optional(),
-    referenceImageUrl: z9.string().url().optional(),
-    referenceImages: z9.array(z9.string().url()).max(8).optional(),
-    aspectRatio: z9.string().regex(/^\d+:\d+$/).optional(),
-    resolution: z9.string().regex(/^\d+x\d+$/).optional(),
-    durationSeconds: z9.number().int().min(1).max(60).optional(),
-    providerParams: z9.record(z9.string(), z9.unknown()).optional()
-  }).strict(),
-  options: z9.object({
-    workflowId: z9.string().uuid().optional(),
-    nodeId: z9.string().optional()
-  }).strict().optional(),
-  products: z9.array(ProductReferenceSchema).min(1).max(10).optional()
-}).strict();
-var GenerateCreateResponseSchema = z9.object({
-  jobId: z9.string().uuid(),
-  status: z9.enum(["queued", "processing", "completed", "failed"]),
-  estimatedSeconds: z9.number().int().nonnegative().nullable(),
-  creditsCharged: z9.number().int().nonnegative()
-}).strict();
-var GenerationStatusSchema = z9.enum([
-  "queued",
-  "processing",
-  "uploading",
-  "completed",
-  "failed",
-  "cancelled"
-]);
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "cancelled"
-]);
-function isTerminalStatus(status) {
-  return TERMINAL_STATUSES.has(status);
-}
-var GenerationResultSchema = z9.object({
-  jobId: z9.string().uuid(),
-  status: GenerationStatusSchema,
-  modelSlug: z9.string(),
-  resultUrl: z9.string().url().nullable(),
-  thumbnailUrl: z9.string().url().nullable(),
-  errorCode: z9.string().nullable(),
-  errorMessage: z9.string().nullable(),
-  creditsCharged: z9.number().int().nonnegative(),
-  creditsRefunded: z9.boolean(),
-  startedAt: z9.string().nullable(),
-  completedAt: z9.string().nullable()
-}).strict();
-
 // src/commands/upload.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { basename } from "path";
 import "undici";
-
-// src/schemas/assets.ts
-import { z as z10 } from "zod";
-var MAX_UPLOAD_SIZE_BYTES = 15 * 1024 * 1024;
-var UploadRequestSchema = z10.object({
-  filename: z10.string().min(1).max(255),
-  contentType: z10.string().regex(/^[\w-]+\/[\w+.-]+$/),
-  sizeBytes: z10.number().int().positive().max(MAX_UPLOAD_SIZE_BYTES),
-  contentHash: z10.string().regex(/^sha256:[0-9a-f]{64}$/)
-}).strict();
-var UploadResponseSchema = z10.object({
-  assetId: z10.string().uuid(),
-  uploadUrl: z10.string().url(),
-  publicUrl: z10.string().url(),
-  deduplicated: z10.boolean()
-}).strict();
-
-// src/commands/upload.ts
 var DEFAULT_UPLOAD_SCOPE = "user-uploads";
 async function uploadFile(opts) {
   const scope = opts.scope ?? DEFAULT_UPLOAD_SCOPE;
@@ -1902,37 +2027,19 @@ function isUrlLike(value) {
   return value.startsWith("http://") || value.startsWith("https://");
 }
 
-// src/commands/generate/get.ts
-async function generateGet(opts) {
-  const client = opts.client ?? await buildGenerateClient(opts);
-  return client.request({
-    method: "GET",
-    path: `/jobs/${encodeURIComponent(opts.jobId)}`,
-    query: opts.waitSeconds && opts.waitSeconds > 0 ? { wait: opts.waitSeconds } : void 0,
-    responseSchema: GenerationResultSchema,
-    signal: opts.signal
-  });
-}
-
 // src/commands/generate/wait.ts
 var DEFAULT_WAIT_TIMEOUT_SECONDS = 120;
 var SERVER_LONG_POLL_SECONDS = 30;
 async function generateWait(opts) {
   const client = opts.client ?? await buildGenerateClient(opts);
-  const timeoutSeconds = opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
-  return longPoll({
-    // Forward the iteration signal so the in-flight server hold is aborted
-    // as soon as the overall deadline expires — otherwise `--timeout 1` would
-    // still block for the full 30s server long-poll round.
-    fetcher: (args) => generateGet({
-      jobId: opts.jobId,
-      waitSeconds: SERVER_LONG_POLL_SECONDS,
-      client,
-      signal: args?.signal
-    }),
-    isTerminal: (r) => isTerminalStatus(r.status),
-    timeoutMs: timeoutSeconds * 1e3,
-    signal: opts.signal
+  return waitForGeneration({
+    client,
+    jobId: opts.jobId,
+    timeoutMs: (opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS) * 1e3,
+    serverWaitSeconds: SERVER_LONG_POLL_SECONDS,
+    signal: opts.signal,
+    resultSchema: GenerationResultSchema,
+    isTerminal: (r) => isTerminalStatus(r.status)
   });
 }
 
@@ -1950,22 +2057,18 @@ async function generateCreate(opts) {
     signal: opts.signal
   });
   const body = buildRequestBody({ ...opts, referenceImages });
-  const created = await client.request({
-    method: "POST",
-    path: "/jobs",
-    body,
-    responseSchema: GenerateCreateResponseSchema,
-    signal: opts.signal
-  });
-  const wait = opts.wait ?? true;
-  if (!wait) {
-    return projectCreateToResult(created, opts.modelSlug);
-  }
-  return generateWait({
-    jobId: created.jobId,
-    timeoutSeconds: opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS,
+  return createGeneration({
     client,
-    signal: opts.signal
+    body,
+    modelSlug: opts.modelSlug,
+    wait: opts.wait ?? true,
+    timeoutMs: (opts.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS) * 1e3,
+    serverWaitSeconds: SERVER_LONG_POLL_SECONDS,
+    signal: opts.signal,
+    createSchema: GenerateCreateResponseSchema,
+    resultSchema: GenerationResultSchema,
+    isTerminal: (r) => isTerminalStatus(r.status),
+    projectCreated: projectCreateToResult
   });
 }
 async function resolveReferenceImages(args) {
@@ -2048,6 +2151,18 @@ function projectCreateToResult(response, modelSlug) {
   };
 }
 
+// src/commands/generate/get.ts
+async function generateGet(opts) {
+  const client = opts.client ?? await buildGenerateClient(opts);
+  return client.request({
+    method: "GET",
+    path: `/jobs/${encodeURIComponent(opts.jobId)}`,
+    query: opts.waitSeconds && opts.waitSeconds > 0 ? { wait: opts.waitSeconds } : void 0,
+    responseSchema: GenerationResultSchema,
+    signal: opts.signal
+  });
+}
+
 // src/cli/args.ts
 var ArgError = class extends Error {
   constructor(message) {
@@ -2697,48 +2812,48 @@ function formatRevokeFailure(err, token) {
 }
 
 // src/schemas/models.ts
-import { z as z11 } from "zod";
-var ModelSummarySchema = z11.object({
-  id: z11.string().uuid(),
-  slug: z11.string(),
-  displayName: z11.string(),
-  description: z11.string().nullable(),
-  shortDescription: z11.string().nullable(),
-  providerSlug: z11.string(),
-  providerName: z11.string(),
-  modelType: z11.string(),
-  category: z11.string(),
-  costTier: z11.string(),
-  creditCost: z11.number(),
-  pricingStrategy: z11.string(),
-  estimatedSeconds: z11.object({
-    typical: z11.number(),
-    range: z11.array(z11.number())
+import { z as z14 } from "zod";
+var ModelSummarySchema = z14.object({
+  id: z14.string().uuid(),
+  slug: z14.string(),
+  displayName: z14.string(),
+  description: z14.string().nullable(),
+  shortDescription: z14.string().nullable(),
+  providerSlug: z14.string(),
+  providerName: z14.string(),
+  modelType: z14.string(),
+  category: z14.string(),
+  costTier: z14.string(),
+  creditCost: z14.number(),
+  pricingStrategy: z14.string(),
+  estimatedSeconds: z14.object({
+    typical: z14.number(),
+    range: z14.array(z14.number())
   }).passthrough().nullable(),
-  status: z11.string(),
-  modalities: z11.object({
-    input: z11.array(z11.string()),
-    output: z11.array(z11.string())
+  status: z14.string(),
+  modalities: z14.object({
+    input: z14.array(z14.string()),
+    output: z14.array(z14.string())
   }).passthrough().nullable(),
-  bestFor: z11.array(z11.string()),
-  badges: z11.array(
-    z11.object({
-      type: z11.string(),
-      label: z11.string(),
-      color: z11.string(),
-      expires_at: z11.string().nullable().optional()
+  bestFor: z14.array(z14.string()),
+  badges: z14.array(
+    z14.object({
+      type: z14.string(),
+      label: z14.string(),
+      color: z14.string(),
+      expires_at: z14.string().nullable().optional()
     }).strict()
   ),
-  isFeatured: z11.boolean(),
-  isDefault: z11.boolean(),
-  docsUrl: z11.string().nullable(),
-  llmContext: z11.string().nullable(),
-  constraints: z11.record(z11.string(), z11.unknown()).nullable(),
-  modelFamily: z11.string().nullable(),
-  isFamilyPrimary: z11.boolean().nullable()
+  isFeatured: z14.boolean(),
+  isDefault: z14.boolean(),
+  docsUrl: z14.string().nullable(),
+  llmContext: z14.string().nullable(),
+  constraints: z14.record(z14.string(), z14.unknown()).nullable(),
+  modelFamily: z14.string().nullable(),
+  isFamilyPrimary: z14.boolean().nullable()
 }).strict();
-var ModelsListResponseSchema = z11.object({
-  models: z11.array(ModelSummarySchema)
+var ModelsListResponseSchema = z14.object({
+  models: z14.array(ModelSummarySchema)
 }).strict();
 
 // src/commands/models/internal.ts
@@ -2774,26 +2889,6 @@ async function listModels(opts) {
   return data;
 }
 
-// src/schemas/node-types.ts
-import { z as z12 } from "zod";
-var NodeTypeSummarySchema = z12.object({
-  type: z12.string(),
-  portCount: z12.number()
-}).strict();
-var NodeTypePortSchema = z12.object({
-  handleId: z12.string(),
-  direction: z12.enum(["input", "output"]),
-  dataType: z12.string()
-}).strict();
-var NodeTypeDetailSchema = z12.object({
-  type: z12.string(),
-  ports: z12.array(NodeTypePortSchema),
-  agentWritableFields: z12.array(z12.string())
-}).strict();
-var NodeTypesListResponseSchema = z12.object({
-  nodeTypes: z12.array(NodeTypeSummarySchema)
-}).strict();
-
 // src/commands/nodes/internal.ts
 async function buildNodesClient(opts) {
   const cfg = await loadConfig({
@@ -2962,36 +3057,6 @@ async function buildTemplateClient(opts) {
   });
 }
 
-// src/schemas/templates.ts
-import { z as z14 } from "zod";
-var DeclaredParamSchema = z14.object({
-  name: z14.string(),
-  type: z14.string(),
-  required: z14.boolean(),
-  defaultValue: z14.string().nullable().optional(),
-  enumValues: z14.array(z14.string()).nullable().optional(),
-  description: z14.string().nullable().optional()
-}).strict();
-var TemplateSummarySchema = z14.object({
-  id: z14.string().uuid(),
-  source: z14.enum(["own", "system"]),
-  name: z14.string(),
-  description: z14.string().nullable(),
-  category: z14.string().nullable(),
-  thumbnailUrl: z14.string().nullable(),
-  tags: z14.array(z14.string()),
-  createdAt: z14.string()
-}).strict();
-var TemplateDetailSchema = TemplateSummarySchema.extend({
-  declaredParams: z14.array(DeclaredParamSchema),
-  timesUsed: z14.number()
-}).strict();
-var TemplatesListResponseSchema = z14.object({
-  templates: z14.array(TemplateSummarySchema),
-  cursor: z14.string().nullable(),
-  hasMore: z14.boolean()
-}).strict();
-
 // src/commands/template/list.ts
 async function listTemplates(opts) {
   const client = opts.client ?? await buildTemplateClient(opts);
@@ -3064,55 +3129,6 @@ async function listTokens(options) {
   return data;
 }
 
-// src/schemas/workflows.ts
-import { z as z16 } from "zod";
-var WorkflowDeclaredParamSchema = z16.object({
-  name: z16.string(),
-  type: z16.string(),
-  required: z16.boolean().optional(),
-  defaultValue: z16.unknown().optional(),
-  description: z16.unknown().optional()
-}).passthrough();
-var WorkflowSummarySchema = z16.object({
-  id: z16.string().uuid(),
-  name: z16.string(),
-  tags: z16.array(z16.string()),
-  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z16.number().int().nonnegative(),
-  updated_at: z16.string()
-}).strict();
-var WorkflowsListResponseSchema = z16.object({
-  items: z16.array(WorkflowSummarySchema),
-  nextCursor: z16.string().nullable()
-}).strict();
-var WorkflowDetailSchema = z16.object({
-  id: z16.string().uuid(),
-  name: z16.string(),
-  description: z16.string().nullable(),
-  tags: z16.array(z16.string()),
-  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z16.number().int().nonnegative(),
-  nodes: z16.array(z16.unknown()),
-  edges: z16.array(z16.unknown()),
-  created_at: z16.string(),
-  updated_at: z16.string()
-}).strict();
-var WorkflowCreateResponseSchema = z16.object({
-  id: z16.string().uuid(),
-  name: z16.string(),
-  description: z16.string().nullable(),
-  tags: z16.array(z16.string()),
-  declared_params: z16.array(WorkflowDeclaredParamSchema).nullable().default([]),
-  canvas_rev: z16.number().int().nonnegative(),
-  created_at: z16.string(),
-  updated_at: z16.string()
-}).strict();
-var WorkflowMutateResponseSchema = z16.object({
-  canvas_rev: z16.number().int().nonnegative(),
-  applied: z16.number().int().nonnegative(),
-  workflow: WorkflowDetailSchema
-}).strict();
-
 // src/commands/workflow/internal.ts
 async function buildWorkflowClient(opts) {
   const cfg = await loadConfig({