dsh-draw 0.1.0

package/lib/types/service.js

@@ -0,0 +1,131 @@
+/**
+ * The `draw` host service: the Typert Remote namespace the settings panel and
+ * the result card consume (`draw/status`, `draw/probe`, `draw/setCredential`,
+ * `draw/unsetCredential`, `draw/regenerate`). Status snapshots are read-only;
+ * credential writes go through the official `ctx.credentials` seam (values
+ * never enter a log or a snapshot); regenerate re-runs the full drawer path
+ * so a panel regeneration is as durable and quota-accounted as a tool call.
+ *
+ * @module dsh-draw/service
+ */
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { engineById } from './config.js';
+import { PLUGIN_VERSION } from './version.js';
+import { imageToWire, probeToWire, statusToView, } from './wire.js';
+/**
+ * The `draw` Typert Remote service.
+ */
+export class DrawService extends TypertRemoteService {
+    /** Per-call bindings (replaced on plugin reload). */
+    options;
+    /**
+     * @param ctx - the mounting context.
+     * @param options - runtime bindings.
+     */
+    constructor(ctx, options) {
+        super(ctx, 'draw');
+        this.options = options;
+    }
+    /** Resolve one engine's credential view for the status snapshot. */
+    async credentialView(reference) {
+        const credentials = this.options.credentials;
+        if (credentials === undefined)
+            return { configured: false, writable: false };
+        try {
+            const info = await credentials.describe(credentialRef(reference));
+            return { configured: info.configured, writable: info.writable, ...(info.source !== undefined ? { source: info.source } : {}) };
+        }
+        catch {
+            return { configured: false, writable: false };
+        }
+    }
+    /** Read-only panel snapshot: engine chain, health, credential facts, quota. */
+    async status() {
+        const { config, router } = this.options;
+        const engines = [];
+        for (const engine of config.engines) {
+            const status = router.statusOf(engine.id);
+            const view = statusToView(status ?? { engineId: engine.id, consecutiveFailures: 0, cooldownUntil: null, lastError: null, lastStatus: null }, {
+                id: engine.id,
+                model: engine.model,
+                baseUrl: engine.baseUrl,
+                apiKeyRef: engine.apiKeyRef,
+                enabled: engine.enabled,
+                preferred: engine.id === config.defaultEngine,
+            }, await this.credentialView(engine.apiKeyRef));
+            engines.push(view);
+        }
+        return {
+            pluginVersion: PLUGIN_VERSION,
+            engines,
+            quota: { maxGenerationsPerSession: config.maxGenerationsPerSession, maxBytesPerSession: config.maxBytesPerSession },
+            requestTimeoutMs: config.requestTimeoutMs,
+            maxImagesPerCall: config.maxImagesPerCall,
+        };
+    }
+    /** Probe one engine's connectivity without mutating routing health. */
+    async probe(engineId) {
+        const engine = engineById(this.options.config, engineId);
+        if (engine === undefined) {
+            return { engineId, reachable: false, httpStatus: null, target: '', note: `unknown engine "${engineId}"`, credentialConfigured: false };
+        }
+        const outcome = await this.options.router.probe(engine, {
+            transport: this.options.drawer.deps.engine.transport,
+            resolveCredential: this.options.drawer.deps.engine.resolveCredential,
+        });
+        return probeToWire(outcome);
+    }
+    /** Store one API key under the engine's credential reference (credentials seam). */
+    async setCredential(engineId, value) {
+        const engine = engineById(this.options.config, engineId);
+        if (engine === undefined)
+            throw new TypeError(`unknown engine "${engineId}"`);
+        const credentials = this.options.credentials;
+        if (credentials === undefined)
+            throw new TypeError('the credential service is not composed on this profile');
+        if (typeof value !== 'string' || value.length === 0)
+            throw new TypeError('credential value must be a non-empty string');
+        await credentials.set(credentialRef(engine.apiKeyRef), value);
+        return { engineId, reference: engine.apiKeyRef, note: `stored under the ${engine.apiKeyRef} credential reference` };
+    }
+    /** Remove a stored API key for the engine's credential reference. */
+    async unsetCredential(engineId) {
+        const engine = engineById(this.options.config, engineId);
+        if (engine === undefined)
+            throw new TypeError(`unknown engine "${engineId}"`);
+        const credentials = this.options.credentials;
+        if (credentials === undefined)
+            throw new TypeError('the credential service is not composed on this profile');
+        await credentials.unset(credentialRef(engine.apiKeyRef));
+        return { engineId, reference: engine.apiKeyRef, note: `removed from the ${engine.apiKeyRef} credential reference` };
+    }
+    /** Re-run a generation from the result card through the full drawer path. */
+    async regenerate(sessionId, args) {
+        const sessions = this.options.drawer.deps.sessions?.();
+        if (sessions === undefined)
+            throw new TypeError('the session store is not composed on this profile');
+        const session = sessions.get(SessionId(sessionId));
+        if (session === undefined)
+            throw new TypeError(`unknown session "${sessionId}"`);
+        const outcome = await this.options.drawer.generate(args, { session, source: 'regenerate' });
+        if (!outcome.ok)
+            throw new TypeError(outcome.message);
+        return projectRegenerate(outcome);
+    }
+}
+/** Project a successful draw onto the regenerate wire shape. */
+function projectRegenerate(outcome) {
+    return {
+        engine: outcome.engine,
+        model: outcome.model,
+        size: outcome.size,
+        images: outcome.images.map(imageToWire),
+        quota: outcome.quota,
+        quotaLimits: outcome.limits,
+        fallbackUsed: outcome.fallbackUsed,
+        elapsedMs: outcome.elapsedMs,
+        attempts: outcome.attempts,
+    };
+}

package/lib/types/session-events.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The dsh-draw session event: one durable record per completed generation
+ * (tool call or panel regenerate), appended to the owning session log. It is
+ * log-only (`ignorable`) and exists so quota accounting and the durable audit
+ * trail are reconstructable from the log alone. The model-visible input and
+ * output of the call ride the loop-owned `tool/call` and `tool/result`
+ * events; this event carries the accounting facts those events do not.
+ *
+ * @module dsh-draw/session-events
+ */
+import type { Session } from '@deepseek-ai/dsh-session';
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * One completed image generation: engine, standardized request, produced
+         * bytes, and the durable attachment ids. Log-only UI/accounting state.
+         */
+        'draw/generated': DrawGeneratedEvent;
+    }
+}
+/** Payload of the `draw/generated` session event. */
+export interface DrawGeneratedEvent {
+    /** Engine id that produced the images. */
+    engine: string;
+    /** Engine model name. */
+    model: string;
+    /** Who requested the generation: the tool body or a panel regenerate. */
+    source: 'tool' | 'regenerate';
+    /** The standardized prompt, verbatim from the model request. */
+    prompt: string;
+    /** Standard size vocabulary value of the request. */
+    size: 'square' | 'landscape' | 'portrait' | 'auto';
+    /** Standard quality value of the request. */
+    quality: 'low' | 'medium' | 'high' | 'auto';
+    /** Number of images produced. */
+    count: number;
+    /** Sum of the produced image byte lengths. */
+    bytes: number;
+    /** Durable attachment ids in result order. */
+    attachmentIds: readonly string[];
+    /** Engine round-trip latency in milliseconds. */
+    elapsedMs: number;
+}
+/**
+ * Append one `draw/generated` event to a session.
+ *
+ * @param session - owning session.
+ * @param event - accounting payload.
+ * @returns the logged event.
+ */
+export declare function appendDrawGenerated(session: Session, event: DrawGeneratedEvent): {
+    type: "draw/generated";
+    seq: number;
+    time: number;
+    data: DrawGeneratedEvent;
+    ignorable?: true;
+} & object;
+/**
+ * Collect the `draw/generated` events of a session in log order. Declaration
+ * merging narrows `event.type === 'draw/generated'` to the payload type.
+ *
+ * @param session - session whose log is scanned.
+ * @returns the accounting events.
+ */
+export declare function drawGeneratedEvents(session: Session): readonly import('@deepseek-ai/dsh-session').SessionEvent<'draw/generated'>[];
+//# sourceMappingURL=session-events.d.ts.map

package/lib/types/session-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-events.d.ts","sourceRoot":"","sources":["../../src/session-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAEvD,OAAO,QAAQ,gCAAgC,CAAC;IAC9C,UAAU,eAAe;QACvB;;;WAGG;QACH,gBAAgB,EAAE,kBAAkB,CAAA;KACrC;CACF;AAED,qDAAqD;AACrD,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAA;IACd,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAA;IAC7B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;IACd,qDAAqD;IACrD,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAA;IAClD,6CAA6C;IAC7C,OAAO,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;IAC3C,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAA;IACb,8CAA8C;IAC9C,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB;;;;;;WAI9E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,OAAO,0BAA0B,EAAE,YAAY,CAAC,gBAAgB,CAAC,EAAE,CAElI"}

package/lib/types/session-events.js

@@ -0,0 +1,32 @@
+/**
+ * The dsh-draw session event: one durable record per completed generation
+ * (tool call or panel regenerate), appended to the owning session log. It is
+ * log-only (`ignorable`) and exists so quota accounting and the durable audit
+ * trail are reconstructable from the log alone. The model-visible input and
+ * output of the call ride the loop-owned `tool/call` and `tool/result`
+ * events; this event carries the accounting facts those events do not.
+ *
+ * @module dsh-draw/session-events
+ */
+/**
+ * Append one `draw/generated` event to a session.
+ *
+ * @param session - owning session.
+ * @param event - accounting payload.
+ * @returns the logged event.
+ */
+export function appendDrawGenerated(session, event) {
+    // Two-argument append: the pinned 0.1.0-rc.6 peers have no append-envelope
+    // option; the two-argument form typechecks against rc.6 and newer builds.
+    return session.append('draw/generated', event);
+}
+/**
+ * Collect the `draw/generated` events of a session in log order. Declaration
+ * merging narrows `event.type === 'draw/generated'` to the payload type.
+ *
+ * @param session - session whose log is scanned.
+ * @returns the accounting events.
+ */
+export function drawGeneratedEvents(session) {
+    return session.events.filter(event => event.type === 'draw/generated');
+}

package/lib/types/tool.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The `image_generate` tool: the model-facing unified image generation entry.
+ * Standard parameters (prompt/size/count/quality/style/engine) flow into the
+ * shared drawer path; the canonical value carries the durable attachment
+ * references plus quota and routing facts, and the render output embeds the
+ * images as attachment content blocks so both text-only surfaces and the web
+ * conversation show them.
+ *
+ * @module dsh-draw/tool
+ */
+import type { ResolvedConfig } from './config.ts';
+import type { Drawer } from './drawer.ts';
+/** Tool argument surface (validated by the schema; the drawer re-normalizes). */
+export interface ImageGenerateArgs {
+    prompt: string;
+    size?: 'square' | 'landscape' | 'portrait' | 'auto';
+    count?: number;
+    quality?: 'low' | 'medium' | 'high' | 'auto';
+    style?: 'natural' | 'vivid';
+    engine?: string;
+}
+/**
+ * Build the `image_generate` tool over one drawer.
+ *
+ * @param drawer - the shared generation path.
+ * @param config - resolved config (prompt cap for the description, timeout budget).
+ * @returns the tool definition.
+ */
+export declare function imageGenerateTool(drawer: Drawer, config: ResolvedConfig): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=tool.d.ts.map

package/lib/types/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,aAAa,CAAA;AAEtD,iFAAiF;AACjF,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAA;IACnD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;IAC5C,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAA;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,mDA6GvE"}

package/lib/types/tool.js

@@ -0,0 +1,131 @@
+/**
+ * The `image_generate` tool: the model-facing unified image generation entry.
+ * Standard parameters (prompt/size/count/quality/style/engine) flow into the
+ * shared drawer path; the canonical value carries the durable attachment
+ * references plus quota and routing facts, and the render output embeds the
+ * images as attachment content blocks so both text-only surfaces and the web
+ * conversation show them.
+ *
+ * @module dsh-draw/tool
+ */
+import { AttachmentId } from '@deepseek-ai/dsh-attachment';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+/**
+ * Build the `image_generate` tool over one drawer.
+ *
+ * @param drawer - the shared generation path.
+ * @param config - resolved config (prompt cap for the description, timeout budget).
+ * @returns the tool definition.
+ */
+export function imageGenerateTool(drawer, config) {
+    return defineTool({
+        name: 'image_generate',
+        description: `Generate 1..${config.maxImagesPerCall} static images from a text prompt through the configured image engines (OpenAI Images, Zhipu CogView, or any OpenAI-compatible endpoint). Standard parameters are translated per engine; a failing engine falls back down the configured chain. Results are saved as durable attachments and count against the per-session quota. Prompt cap: ${config.maxPromptLength} characters.`,
+        parameters: {
+            prompt: { type: 'string', description: 'Image prompt.', required: true },
+            size: { type: 'string', enum: ['square', 'landscape', 'portrait', 'auto'], description: 'Composition (default square).' },
+            count: { type: 'integer', description: 'Number of images (default 1; capped by configuration).' },
+            quality: { type: 'string', enum: ['low', 'medium', 'high', 'auto'], description: 'Quality tier (default auto; dropped for engines without it).' },
+            style: { type: 'string', enum: ['natural', 'vivid'], description: 'Style preset (dropped for engines without it).' },
+            engine: { type: 'string', description: 'Engine id override (must name a configured engine; omitted = chain order).' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    ok: { type: 'boolean', const: true },
+                    engine: { type: 'string' },
+                    model: { type: 'string' },
+                    size: { type: 'string' },
+                    images: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                attachmentId: { type: 'string' },
+                                mediaType: { type: 'string' },
+                                bytes: { type: 'integer' },
+                                width: { type: 'integer' },
+                                height: { type: 'integer' },
+                                name: { type: 'string' },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    quota: {
+                        type: 'object',
+                        properties: {
+                            generations: { type: 'integer' },
+                            bytes: { type: 'integer' },
+                        },
+                        additionalProperties: false,
+                    },
+                    limits: {
+                        type: 'object',
+                        properties: {
+                            maxGenerations: { type: 'integer' },
+                            maxBytes: { type: 'integer' },
+                        },
+                        additionalProperties: false,
+                    },
+                    fallbackUsed: { type: 'boolean' },
+                    elapsedMs: { type: 'integer' },
+                    attempts: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                engine: { type: 'string' },
+                                phase: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+                                code: { type: 'string' },
+                                message: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+                                status: { oneOf: [{ type: 'integer' }, { type: 'null' }] },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+            render(_args, value) {
+                const result = value;
+                const lines = [
+                    `Generated ${result.images.length} image(s) via ${result.engine} (${result.model}, ${result.size})${result.fallbackUsed ? ' after fallback' : ''} in ${result.elapsedMs} ms.`,
+                    `Quota: ${result.quota.generations}/${result.limits.maxGenerations} calls, ${result.quota.bytes}/${result.limits.maxBytes} bytes this session.`,
+                ];
+                for (const attempt of result.attempts) {
+                    if (attempt.code === 'ok')
+                        continue;
+                    lines.push(`- ${attempt.engine}: ${attempt.code}${attempt.message === undefined ? '' : ` (${attempt.message})`}`);
+                }
+                const blocks = [{ type: 'text', text: lines.join('\n') }];
+                for (const image of result.images) {
+                    const attachment = {
+                        attachmentId: AttachmentId(image.attachmentId),
+                        mediaType: image.mediaType,
+                        bytes: image.bytes,
+                        width: image.width,
+                        height: image.height,
+                        ...(image.name !== undefined ? { name: image.name } : {}),
+                    };
+                    blocks.push({ type: 'image', attachment });
+                }
+                return blocks;
+            },
+            // The result card reads the canonical value through this replayable
+            // presentation projection (the frozen client block exposes only `meta`).
+            presentationMeta(_args, value) {
+                return value;
+            },
+        },
+        timeoutMs: config.requestTimeoutMs,
+        async execute(args, exec) {
+            const outcome = await drawer.generate(args, { session: exec.agent?.session, source: 'tool', signal: exec.signal });
+            if (!outcome.ok)
+                throw new Error(outcome.message);
+            // The schema-inferred canonical value owns mutable arrays; the drawer's
+            // frozen records are copied into owned mutable ones here.
+            return { ...outcome, images: [...outcome.images], attempts: [...outcome.attempts] };
+        },
+    });
+}

package/lib/types/translate.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Standard-parameter translation: the tool-level vocabulary
+ * (`prompt`/size/count/quality/style) mapped onto one concrete engine's
+ * request. Pure functions with no I/O — unit tests pin every mapping.
+ *
+ * @module dsh-draw/translate
+ */
+import type { ResolvedEngineConfig, StandardSize } from './config.ts';
+/** Standard quality vocabulary; `auto` means "leave the engine default". */
+export type StandardQuality = 'low' | 'medium' | 'high' | 'auto';
+/** Standard style vocabulary (engines that lack styles drop it). */
+export type StandardStyle = 'natural' | 'vivid';
+/** Standard tool-level image request. */
+export interface StandardImageRequest {
+    /** Image prompt, non-empty and within the configured length cap. */
+    prompt: string;
+    /** Standard size vocabulary (default `square`). */
+    size?: StandardSize;
+    /** Number of images (default 1; capped by the engine/config). */
+    count?: number;
+    /** Standard quality vocabulary (default `auto`). */
+    quality?: StandardQuality;
+    /** Standard style vocabulary; omitted = engine default. */
+    style?: StandardStyle;
+    /** Engine id override; omitted = the router's chain order. */
+    engine?: string;
+}
+/** Concrete per-engine request body fields. */
+export interface TranslatedImageRequest {
+    /** Engine model name. */
+    model: string;
+    /** Prompt, verbatim. */
+    prompt: string;
+    /** Concrete engine size string. */
+    size: string;
+    /** Number of images. */
+    n: number;
+    /** Included only when the engine declares quality support and it is not `auto`. */
+    quality?: StandardQuality;
+    /** Included only when the engine declares style support and one was requested. */
+    style?: StandardStyle;
+    /** How the response delivers bytes. */
+    responseFormat: 'b64_json' | 'url';
+}
+/**
+ * Normalize unvalidated tool args to a {@link StandardImageRequest}; malformed
+ * values fall back to defaults. The prompt passes through verbatim — length
+ * validation is the drawer's job (an over-long prompt fails the call loudly
+ * instead of being silently truncated).
+ *
+ * @param args - unvalidated tool arguments.
+ * @param maxImagesPerCall - configured cap the requested count clamps to.
+ * @returns the normalized request.
+ */
+export declare function normalizeRequest(args: unknown, maxImagesPerCall: number): StandardImageRequest;
+/**
+ * Translate one standardized request into a concrete engine request.
+ *
+ * @param engine - resolved engine configuration.
+ * @param request - normalized standard request.
+ * @returns the engine request fields.
+ */
+export declare function translateRequest(engine: ResolvedEngineConfig, request: StandardImageRequest): TranslatedImageRequest;
+//# sourceMappingURL=translate.d.ts.map

package/lib/types/translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.d.ts","sourceRoot":"","sources":["../../src/translate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAErE,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAEhE,oEAAoE;AACpE,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,OAAO,CAAA;AAE/C,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAA;IACd,mDAAmD;IACnD,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oDAAoD;IACpD,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAA;IACT,mFAAmF;IACnF,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,kFAAkF;IAClF,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,uCAAuC;IACvC,cAAc,EAAE,UAAU,GAAG,KAAK,CAAA;CACnC;AAMD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,GAAG,oBAAoB,CAe9F;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,GAAG,sBAAsB,CAYpH"}

package/lib/types/translate.js

@@ -0,0 +1,56 @@
+/**
+ * Standard-parameter translation: the tool-level vocabulary
+ * (`prompt`/size/count/quality/style) mapped onto one concrete engine's
+ * request. Pure functions with no I/O — unit tests pin every mapping.
+ *
+ * @module dsh-draw/translate
+ */
+const SIZES = ['square', 'landscape', 'portrait', 'auto'];
+const QUALITIES = ['low', 'medium', 'high', 'auto'];
+const STYLES = ['natural', 'vivid'];
+/**
+ * Normalize unvalidated tool args to a {@link StandardImageRequest}; malformed
+ * values fall back to defaults. The prompt passes through verbatim — length
+ * validation is the drawer's job (an over-long prompt fails the call loudly
+ * instead of being silently truncated).
+ *
+ * @param args - unvalidated tool arguments.
+ * @param maxImagesPerCall - configured cap the requested count clamps to.
+ * @returns the normalized request.
+ */
+export function normalizeRequest(args, maxImagesPerCall) {
+    const record = typeof args === 'object' && args !== null ? args : {};
+    const prompt = typeof record['prompt'] === 'string' ? record['prompt'] : '';
+    const rawSize = record['size'];
+    const size = typeof rawSize === 'string' && SIZES.includes(rawSize) ? rawSize : 'square';
+    const rawCount = record['count'];
+    const parsedCount = typeof rawCount === 'number' ? Math.trunc(rawCount) : 1;
+    const count = Math.min(Math.max(Number.isFinite(parsedCount) ? parsedCount : 1, 1), maxImagesPerCall);
+    const rawQuality = record['quality'];
+    const quality = typeof rawQuality === 'string' && QUALITIES.includes(rawQuality) ? rawQuality : 'auto';
+    const rawStyle = record['style'];
+    const style = typeof rawStyle === 'string' && STYLES.includes(rawStyle) ? rawStyle : undefined;
+    const rawEngine = record['engine'];
+    const engine = typeof rawEngine === 'string' && rawEngine.length > 0 ? rawEngine : undefined;
+    return { prompt, size, count, quality, ...(style !== undefined ? { style } : {}), ...(engine !== undefined ? { engine } : {}) };
+}
+/**
+ * Translate one standardized request into a concrete engine request.
+ *
+ * @param engine - resolved engine configuration.
+ * @param request - normalized standard request.
+ * @returns the engine request fields.
+ */
+export function translateRequest(engine, request) {
+    const size = engine.sizeMap[request.size ?? 'square'];
+    const requestBody = {
+        model: engine.model,
+        prompt: request.prompt,
+        size,
+        n: request.count ?? 1,
+        ...(engine.qualitySupported && request.quality !== 'auto' ? { quality: request.quality } : {}),
+        ...(engine.styleSupported && request.style !== undefined ? { style: request.style } : {}),
+        responseFormat: engine.responseFormat,
+    };
+    return requestBody;
+}