@drawcall/market 0.1.74 → 0.1.76

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 {
@@ -122,12 +122,13 @@ function assetLine(asset: { name: string; version: string; type: string }): stri
 }
 
 function assetFileLines(paths: string[]): string[] {
-  const lines: string[] = []
-  const files = unique(paths)
-  if (files.length > 0) {
-    lines.push('  files:', ...indent(fileTree(files), '    '))
-  }
-  return lines
+  const files = unique(paths).sort((a, b) => a.localeCompare(b))
+  if (files.length === 0) return []
+  return ['  files:', ...files.map((file) => `    ${installedFileLine(file)}`)]
+}
+
+function installedFileLine(file: string): string {
+  return file.startsWith('public/') ? `${file} -> browser: /${file.slice('public/'.length)}` : file
 }
 
 function block(label: string, message: string, width = 68): string[] {
@@ -161,13 +162,17 @@ export function generatedInstallResult(
 export function generationStartedResult(jobId: string): string {
   return [
     'Still generating after the normal wait — it continues in the background.',
-    `Run this to pick up where it left off and install when ready:  market generate install ${jobId}`,
+    `Resume this same job and install when ready:  ${generationInstallCommand(jobId)}`,
   ].join('\n')
 }
 
 // Printed by `generate install` when the job is still running after its wait window.
 export function generationRunningResult(jobId: string): string {
-  return `Still generating. Run again to continue:  market generate install ${jobId}`
+  return `Still generating. Resume this same job:  ${generationInstallCommand(jobId)}`
+}
+
+function generationInstallCommand(jobId: string): string {
+  return `npx @drawcall/market@latest generate install ${jobId} --cwd "$PWD"`
 }
 
 export function uploadResult(name: string, version: string): string {
@@ -217,53 +222,10 @@ function normalizeInline(value: string): string {
   return value.replace(/\s+/g, ' ').trim()
 }
 
-interface FileTreeNode {
-  children: Map<string, FileTreeNode>
-}
-
-function fileTree(paths: string[]): string[] {
-  const root: FileTreeNode = { children: new Map() }
-
-  for (const filePath of paths) {
-    const parts = filePath.split('/').filter(Boolean)
-    let node = root
-    for (const part of parts) {
-      let child = node.children.get(part)
-      if (!child) {
-        child = { children: new Map() }
-        node.children.set(part, child)
-      }
-      node = child
-    }
-  }
-
-  return renderFileTree(root)
-}
-
-function renderFileTree(node: FileTreeNode, prefix = '', showConnector = false): string[] {
-  const entries = [...node.children.entries()].sort(([aName, aNode], [bName, bNode]) => {
-    const aIsDir = aNode.children.size > 0
-    const bIsDir = bNode.children.size > 0
-    if (aIsDir !== bIsDir) return aIsDir ? -1 : 1
-    return aName.localeCompare(bName)
-  })
-
-  return entries.flatMap(([name, child], index) => {
-    const isLast = index === entries.length - 1
-    const connector = showConnector ? (isLast ? '└─ ' : '├─ ') : ''
-    const childPrefix = showConnector ? prefix + (isLast ? '   ' : '│  ') : ''
-    return [`${prefix}${connector}${name}`, ...renderFileTree(child, childPrefix, true)]
-  })
-}
-
 function unique<T>(values: T[]): T[] {
   return [...new Set(values)]
 }
 
-function indent(lines: string[], prefix: string): string[] {
-  return lines.map((line) => `${prefix}${line}`)
-}
-
 function dependencyLines(label: string, deps: Record<string, string>): string[] {
   const entries = Object.entries(deps)
   if (entries.length === 0) return []

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 two.
+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(2)
+
 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). 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