@drawcall/market 0.1.75 → 0.1.77

package/src/contract.ts

@@ -3,8 +3,6 @@ import { z } from 'zod'
 import type { AssetFileManifest } from './schemas.js'
 import {
   MAX_UPLOAD_ZIP_SIZE_BYTES,
-  agentControlResultSchema,
-  agentDeferredStartSchema,
   agentRunStatusSchema,
   agentStartSchema,
   agentStatusSchema,
@@ -104,6 +102,8 @@ export interface AssetInstallMetadata {
   installMessage?: string
   /** Omitted by Market APIs released before capability discovery. */
   canGenerate?: boolean
+  /** Whether `generate` takes reference images for this type. */
+  acceptsReferenceImages?: boolean
   saveOnInstall: boolean
   readAssetDependenciesFromPackageJson: boolean
   omitUnchangedInstalledFilesOnUpload: boolean
@@ -149,16 +149,10 @@ export const contract = {
     // The agent plans, searches, judges and (where supported) generates a set of
     // assets from a goal. `start` kicks off an async run; `status` long-polls it
     // (blocks until the run settles or a heartbeat window elapses). The
-    // `agentAndWait` drives ordinary runs. A safety-critical deferred caller
-    // uses fail-closed `startDeferred`, observes `status`, then calls `approve`
-    // or `cancel`. Deferred semantics deliberately do not exist on `start`:
-    // an older worker could strip an unknown optional flag and spend immediately.
+    // `agentAndWait` client helper drives both.
     agent: {
       start: oc.input(agentStartSchema).output(z.object({ runId: z.string() })),
-      startDeferred: oc.input(agentDeferredStartSchema).output(z.object({ runId: z.string() })),
       status: oc.input(agentStatusSchema).output(agentRunStatusSchema),
-      approve: oc.input(agentStatusSchema).output(agentControlResultSchema),
-      cancel: oc.input(agentStatusSchema).output(agentControlResultSchema),
     },
   },
 

package/src/generate.ts

@@ -11,6 +11,8 @@ export class GenerateError extends Error {
 export interface GenerateInput {
   description: string
   type?: AssetType
+  /** Reference images (https URL or data URI) the result should match. */
+  referenceImages?: string[]
   /** Requested visibility; omitted lets the server resolve it from entitlement. */
   access?: AssetAccess
 }

package/src/index.ts

@@ -67,11 +67,7 @@ export {
   updateProfileSchema,
   listAssetsSchema,
   agentStartSchema,
-  agentDeferredStartSchema,
   agentStatusSchema,
-  agentGenerationStateSchema,
-  agentControlStateSchema,
-  agentControlResultSchema,
   agentResultAssetSchema,
   agentResultSchema,
   agentRunStatusSchema,
@@ -87,9 +83,6 @@ export type {
   AgentResultAsset,
   AgentResult,
   AgentRunStatus,
-  AgentGenerationState,
-  AgentControlState,
-  AgentControlResult,
   GenerateResponse,
   GenerateJobStatus,
 } from './schemas.js'

package/src/output.ts

@@ -103,7 +103,7 @@ export function assetTypesResult(metadata: Record<string, AssetInstallMetadata>)
 
   const lines = ['Asset types:']
   for (const [type, details] of types) {
-    lines.push(`- ${type} (${assetCapabilities(details.canGenerate)})`)
+    lines.push(`- ${type} (${assetCapabilities(details)})`)
     if (details.searchMessage) {
       lines.push(...block('  search: ', details.searchMessage))
     }
@@ -111,10 +111,10 @@ export function assetTypesResult(metadata: Record<string, AssetInstallMetadata>)
   return lines.join('\n')
 }
 
-function assetCapabilities(canGenerate: boolean | undefined): string {
-  if (canGenerate === true) return 'search, generate'
-  if (canGenerate === false) return 'search only'
-  return 'search, generation unknown'
+function assetCapabilities(details: AssetInstallMetadata): string {
+  if (details.canGenerate === undefined) return 'search, generation unknown'
+  if (!details.canGenerate) return 'search only'
+  return details.acceptsReferenceImages ? 'search, generate (reference images)' : 'search, generate'
 }
 
 function assetLine(asset: { name: string; version: string; type: string }): string {

package/src/schemas.ts

@@ -106,9 +106,26 @@ export const fileManifestSchema = z.object({
  */
 export type AssetFileManifest = Record<string, string>
 
+// A phone-photo data URI is a few MB; this bounds worker and model payloads while staying far
+// above what providers keep (images are downscaled upstream).
+const MAX_REFERENCE_IMAGE_CHARS = 10_000_000
+
+// Reference images the generated asset should match, each an http(s) URL or a
+// `data:image/<type>;base64,<data>` URI. Only providers that declare
+// `acceptsReferenceImages` take them, and none takes more than four.
+export const referenceImagesSchema = z
+  .array(
+    z
+      .string()
+      .max(MAX_REFERENCE_IMAGE_CHARS)
+      .regex(/^(https?:\/\/|data:image\/)/, 'Must be an http(s) URL or a data:image URI'),
+  )
+  .max(4)
+
 export const generateAssetSchema = z.object({
   description: assetDescriptionSchema.min(3),
   type: assetTypeSchema.optional(),
+  referenceImages: referenceImagesSchema.optional(),
   // Requested visibility of the generated asset (same resolution as upload).
   access: assetAccessSchema.optional(),
 })
@@ -143,47 +160,16 @@ export type GenerateJobStatus = z.infer<typeof generateJobStatusSchema>
 
 // The agent takes a natural-language goal (which carries the count and kinds,
 // e.g. "3 low poly stones" or "a template for a zombie game, none if no fit")
-// and optional reference images as base64 (raw or data URLs).
+// and optional reference images (http(s) URL or data URI).
 export const agentStartSchema = z.strictObject({
   goal: z.string().min(3).max(1000),
-  images: z.array(z.string()).optional(),
-})
-
-// A distinct procedure lets safety-critical callers fail closed against an
-// older worker: an unknown `startDeferred` starts nothing. Deferred runs are
-// goal-only because their restart input is persisted until the wall deadline;
-// accepting unbounded base64 reference images would make that unsafe.
-export const agentDeferredStartSchema = z.strictObject({
-  goal: agentStartSchema.shape.goal,
-  runId: z.string().uuid(),
+  referenceImages: referenceImagesSchema.optional(),
 })
 
 export const agentStatusSchema = z.object({
   runId: z.string().min(1),
 })
 
-export const agentGenerationStateSchema = z.enum([
-  'deferred',
-  'awaiting-approval',
-  'approved',
-  'generation-started',
-])
-export type AgentGenerationState = z.infer<typeof agentGenerationStateSchema>
-
-export const agentControlStateSchema = z.enum([
-  ...agentGenerationStateSchema.options,
-  'completed',
-  'failed',
-  'cancelled',
-])
-export type AgentControlState = z.infer<typeof agentControlStateSchema>
-
-export const agentControlResultSchema = z.object({
-  accepted: z.boolean(),
-  state: agentControlStateSchema,
-})
-export type AgentControlResult = z.infer<typeof agentControlResultSchema>
-
 // One chosen asset: a verified, installable `name@version` (the agent only
 // returns names the catalog resolved) plus a note on what it contributes.
 export const agentResultAssetSchema = z.object({
@@ -203,27 +189,12 @@ export const agentResultSchema = z.object({
 })
 export type AgentResult = z.infer<typeof agentResultSchema>
 
-// An agent run is an async job: it is running (with optional generation-gate
-// progress), completed, failed, or explicitly cancelled. A discriminated union
-// keeps "completed without a result" and "failed without an error"
+// An agent run is an async job: running, completed, or failed. A discriminated
+// union keeps "completed without a result" and "failed without an error"
 // unrepresentable.
 export const agentRunStatusSchema = z.discriminatedUnion('status', [
-  z.object({
-    status: z.literal('running'),
-    // Optional so a new client can still read a running response from an older
-    // worker during a rolling deploy.
-    generation: agentGenerationStateSchema.optional(),
-  }),
-  z.object({
-    status: z.literal('completed'),
-    result: agentResultSchema,
-    generationStarted: z.boolean().optional(),
-  }),
-  z.object({
-    status: z.literal('failed'),
-    error: z.string(),
-    generationStarted: z.boolean().optional(),
-  }),
-  z.object({ status: z.literal('cancelled'), generationStarted: z.boolean().optional() }),
+  z.object({ status: z.literal('running') }),
+  z.object({ status: z.literal('completed'), result: agentResultSchema }),
+  z.object({ status: z.literal('failed'), error: z.string() }),
 ])
 export type AgentRunStatus = z.infer<typeof agentRunStatusSchema>

package/src/skill.ts

@@ -33,6 +33,8 @@ Install prints the exact files it wrote. It never searches or generates. With no
 
 \`npx @drawcall/market generate --type <type> "<description>"\` creates and installs one provider-supported asset. It requires login and normally waits through provider generation before printing exact installed paths and type-specific usage guidance. Unsupported types report an error. If an unusually long job returns a continuation, run the printed \`generate install <jobId>\`; it resumes the same server-side job rather than generating again.
 
+Add repeatable \`--reference-image <file-or-url>\` when the result should match given images; \`types\` shows which asset types accept reference images. A humanoid-model keeps the face and distinctive features of the person shown (at most 2 images); an environment matches the look of the references (at most 4). Types without reference image support reject them.
+
 Add \`--access public\` or \`--access private\` when visibility matters. Omitted access follows the account entitlement; private generation requires \`market:private\`.
 
 ## Publish only when asked