dsh-modellix 0.2.1 → 0.3.0

package/lib/index.d.ts

@@ -7,7 +7,6 @@ import { z as z$1 } from "zod";
 import { ToolDefinition } from "@deepseek-ai/dsh-tools";
 import { Context } from "@deepseek-ai/cordis";
 import { Agent } from "@deepseek-ai/dsh-agent";
-import { ImageMediaType } from "@deepseek-ai/dsh-attachment";
 
 //#region src/core/config.d.ts
 declare const CURRENT_CONFIG_SCHEMA_VERSION: 1;
@@ -530,7 +529,7 @@ declare function extractAllowedSubmitUrl(document: Readonly<Record<string, unkno
 interface PreparedMediaUpload {
   readonly bytes: Uint8Array;
   readonly filename: string;
-  readonly mimeType: ImageMediaType;
+  readonly mimeType: string;
 }
 interface MediaUploadRecord {
   readonly fileId: string;
@@ -721,6 +720,7 @@ interface ReadPredictionInput {
   readonly apiKey: string;
   readonly maxAttempts?: number;
   readonly signal?: AbortSignal;
+  readonly waitSeconds?: number;
 }
 declare class PredictionClient {
   #private;
@@ -729,6 +729,10 @@ declare class PredictionClient {
   submit(input: SubmitPredictionInput): Promise<PredictionTask>;
   /** GET retries only transient read failures and is capped at five attempts. */
   readTask(input: ReadPredictionInput): Promise<PredictionTask>;
+  /** Wait for one bounded server observation; does not submit or sleep between snapshots. */
+  waitTask(input: Omit<ReadPredictionInput, "waitSeconds"> & {
+    readonly timeoutSeconds?: number;
+  }): Promise<PredictionTask>;
 }
 declare function validateSubmitEndpoint(endpoint: string, modelSlug: string): URL;
 declare function parsePredictionTask(payload: unknown, expectedTaskId?: string): PredictionTask | null;
@@ -897,6 +901,7 @@ interface CredentialSnapshot {
   readonly credentialEpoch: number;
 }
 interface DesignHostControllerOptions {
+  readonly serializeObservation?: (operation: () => Promise<void>) => Promise<void>;
   readonly storage: StoragePort;
   readonly resolveCredential: () => Promise<CredentialSnapshot | undefined>;
   readonly isCredentialEpochCurrent: (credentialEpoch: number) => boolean;
@@ -988,6 +993,7 @@ declare class DesignHostController {
   constructor(options: DesignHostControllerOptions);
   handle(endpoint: string, payload: unknown, signal?: AbortSignal): Promise<DesignSnapshotWire>;
   pollRunning(signal?: AbortSignal): Promise<boolean>;
+  invalidateWaits(): void;
   private read;
   private refresh;
   private selectModel;

package/lib/index.js

@@ -4,7 +4,7 @@ import { getOrCreateAnonymousUserId } from "@deepseek-ai/dsh-anonymous-user-id";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { SettingsConflictError } from "@deepseek-ai/dsh-settings";
 import { lstat, open, realpath } from "node:fs/promises";
-import { basename, isAbsolute, relative, resolve } from "node:path";
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 import { WebError } from "@deepseek-ai/dsh-web";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
@@ -1547,6 +1547,10 @@ var MediaUploadClient = class {
 			throw new DesignError("SUBMIT_UNKNOWN", "The media upload outcome is unknown; do not retry automatically", { status: response.status });
 		}
 		if (!response.ok) {
+			if (response.status === 429) {
+				response.body?.cancel().catch(() => void 0);
+				throw new DesignError("SUBMIT_REJECTED", "Upload quota exceeded. List existing files and explicitly delete only unneeded files before trying again; no automatic cleanup was performed", { status: 429 });
+			}
 			const ambiguous = response.status === 408 || response.status === 409 || response.status === 425 || response.status === 429 || response.status >= 500;
 			response.body?.cancel().catch(() => void 0);
 			throw new DesignError(ambiguous ? "SUBMIT_UNKNOWN" : "SUBMIT_REJECTED", ambiguous ? "The media upload outcome is unknown; do not retry automatically" : `The media upload was rejected with HTTP ${String(response.status)}`, { status: response.status });
@@ -1591,12 +1595,19 @@ async function prepareMediaUploadFromPath(cwd, inputPath) {
 	try {
 		const opened = await handle.stat();
 		if (!opened.isFile() || opened.size !== before.size || opened.dev !== before.dev || opened.ino !== before.ino) throw new DesignError("INVALID_ARGUMENT", "Media file changed while it was being opened");
-		bytes = await handle.readFile();
+		const bounded = Buffer.alloc(before.size + 1);
+		let offset = 0;
+		while (offset < bounded.length) {
+			const { bytesRead } = await handle.read(bounded, offset, bounded.length - offset, null);
+			if (bytesRead === 0) break;
+			offset += bytesRead;
+		}
+		bytes = bounded.subarray(0, offset);
 	} finally {
 		await handle.close();
 	}
 	if (bytes.byteLength !== before.size) throw new DesignError("INVALID_ARGUMENT", "Media file changed while it was being read");
-	const mimeType = detectImageMimeType(bytes);
+	const mimeType = detectMediaMimeType(bytes, resolved);
 	return {
 		bytes,
 		filename: safeFilename(basename(resolved), mimeType),
@@ -1611,7 +1622,74 @@ function within(root, candidate) {
 	const suffix = relative(root, candidate);
 	return suffix === "" || !suffix.startsWith("..") && !isAbsolute(suffix);
 }
-function detectImageMimeType(bytes) {
+const MEDIA_EXTENSIONS = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	webp: "image/webp",
+	gif: "image/gif",
+	bmp: "image/bmp",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	heic: "image/heic",
+	heif: "image/heif",
+	mp4: "video/mp4",
+	m4v: "video/x-m4v",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	mkv: "video/x-matroska",
+	avi: "video/x-msvideo",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	m4a: "audio/mp4",
+	aac: "audio/aac",
+	ogg: "audio/ogg",
+	flac: "audio/flac",
+	opus: "audio/opus",
+	weba: "audio/webm"
+};
+function detectMediaMimeType(bytes, filename) {
+	const extension = extname(filename).slice(1).toLowerCase();
+	const expected = MEDIA_EXTENSIONS[extension];
+	if (expected === void 0) throw new DesignError("INVALID_ARGUMENT", "Unsupported media file extension");
+	const head = Buffer.from(bytes.subarray(0, 16)).toString("latin1");
+	const riffType = head.startsWith("RIFF") ? head.slice(8, 12) : "";
+	const iso = bytes.length >= 12 && head.slice(4, 8) === "ftyp";
+	const ebml = head.startsWith("Eߣ");
+	const audioFrame = bytes.length >= 2 && bytes[0] === 255 && ((bytes[1] ?? 0) & 224) === 224;
+	const tiff = [
+		73,
+		73,
+		42,
+		0
+	].every((byte, index) => bytes[index] === byte) || [
+		77,
+		77,
+		0,
+		42
+	].every((byte, index) => bytes[index] === byte);
+	if ({
+		gif: /^GIF8[79]a/u.test(head),
+		bmp: head.startsWith("BM"),
+		tif: tiff,
+		tiff,
+		heic: iso && /^(?:heic|heix|hevc|hevx|mif1)$/u.test(head.slice(8, 12)),
+		heif: iso && /^(?:heic|heix|hevc|hevx|mif1|msf1)$/u.test(head.slice(8, 12)),
+		mp4: iso,
+		m4v: iso,
+		m4a: iso,
+		mov: iso || head.slice(4, 8) === "moov",
+		avi: riffType === "AVI ",
+		wav: riffType === "WAVE",
+		webm: ebml,
+		mkv: ebml,
+		weba: ebml,
+		mp3: head.startsWith("ID3") || audioFrame,
+		aac: audioFrame,
+		ogg: head.startsWith("OggS"),
+		opus: head.startsWith("OggS"),
+		flac: head.startsWith("fLaC")
+	}[extension] === true) return expected;
 	if (bytes.length >= 8 && bytes.slice(0, 8).every((value, index) => value === [
 		137,
 		80,
@@ -1621,14 +1699,18 @@ function detectImageMimeType(bytes) {
 		10,
 		26,
 		10
-	][index])) return "image/png";
-	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+	][index]) && expected === "image/png") return expected;
+	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+		if (expected === "image/jpeg") return expected;
+	}
 	const ascii = (start, end) => new TextDecoder("ascii").decode(bytes.slice(start, end));
-	if (bytes.length >= 12 && ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return "image/webp";
-	throw new DesignError("INVALID_ARGUMENT", "Unsupported media type; use PNG, JPEG, or WebP");
+	if (bytes.length >= 12 && ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") {
+		if (expected === "image/webp") return expected;
+	}
+	throw new DesignError("INVALID_ARGUMENT", "Unsupported media type or content does not match its extension");
 }
 function safeFilename(value, mimeType) {
-	const extension = mimeType === "image/png" ? ".png" : mimeType === "image/webp" ? ".webp" : ".jpg";
+	const extension = `.${Object.entries(MEDIA_EXTENSIONS).find(([, type]) => type === mimeType)?.[0] ?? "bin"}`;
 	const headerSafe = value.normalize("NFC").replaceAll(/["\\/]/gu, "_");
 	const cleaned = Array.from(headerSafe, (character) => {
 		const codePoint = character.codePointAt(0) ?? 0;
@@ -2510,10 +2592,18 @@ var PredictionClient = class {
 		const apiKey = validateApiKey(input.apiKey);
 		const maxAttempts = boundedAttempts(input.maxAttempts ?? 3);
 		const url = new URL(`/api/v1/tasks/${encodeURIComponent(taskId)}`, PREDICTION_ORIGIN);
+		if (input.waitSeconds !== void 0) {
+			if (!Number.isSafeInteger(input.waitSeconds) || input.waitSeconds < 1 || input.waitSeconds > 45) throw new DesignError("INVALID_ARGUMENT", "Wait duration must be an integer from 1 to 45 seconds");
+			url.searchParams.set("wait", "true");
+			url.searchParams.set("timeout", String(input.waitSeconds));
+		}
+		const totalTimeout = input.waitSeconds === void 0 ? this.#requestTimeoutMs : input.waitSeconds * 1e3 + 5e3;
+		const overall = input.waitSeconds === void 0 ? void 0 : requestDeadline(input.signal, totalTimeout);
 		let lastFailure = null;
 		for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
 			input.signal?.throwIfAborted();
-			const deadline = requestDeadline(input.signal, this.#requestTimeoutMs);
+			overall?.signal.throwIfAborted();
+			const deadline = overall ?? requestDeadline(input.signal, this.#requestTimeoutMs);
 			try {
 				const response = await this.#fetch(url, {
 					method: "GET",
@@ -2531,7 +2621,7 @@ var PredictionClient = class {
 						retryAfterMs: failure.retryAfterMs
 					});
 					lastFailure = failure;
-					await this.#waitBeforeRetry(attempt, failure.retryAfterMs, input.signal);
+					await this.#waitBeforeRetry(attempt, failure.retryAfterMs, overall?.signal ?? input.signal);
 					continue;
 				}
 				let payload;
@@ -2543,6 +2633,10 @@ var PredictionClient = class {
 				}
 				const task = parsePredictionTask(payload, taskId);
 				if (task === null) throw new DesignError("UNEXPECTED_RESPONSE", "Task status response does not contain a valid task");
+				if (input.waitSeconds !== void 0 && (task.status === "queued" || task.status === "running")) {
+					const wait = asRecord$3(asRecord$3(asRecord$3(payload)?.data)?.wait);
+					if (typeof wait?.timed_out !== "boolean" || typeof wait.elapsed_ms !== "number") throw new DesignError("UNEXPECTED_RESPONSE", "The task API does not support server-side wait; keep the task ID and do not resubmit");
+				}
 				this.#log({
 					level: "info",
 					event: "design.task.read",
@@ -2555,22 +2649,30 @@ var PredictionClient = class {
 			} catch (caught) {
 				if (input.signal?.aborted === true) throw caught;
 				if (deadline.timedOut()) {
-					if (attempt === maxAttempts) throw new DesignError("TASK_READ_FAILED", "Task status request timed out within the retry bound", {
+					if (attempt === maxAttempts || input.waitSeconds !== void 0) throw new DesignError("TASK_READ_FAILED", "Task status request timed out within the retry bound", {
 						cause: caught,
 						status: 408
 					});
 					lastFailure = caught;
-					await this.#waitBeforeRetry(attempt, null, input.signal);
+					await this.#waitBeforeRetry(attempt, null, overall?.signal ?? input.signal);
 					continue;
 				}
 				if (caught instanceof DesignError) throw caught;
 				if (isAbortError$1(caught) || attempt === maxAttempts) throw new DesignError("TASK_READ_FAILED", "Task status could not be read within the retry bound", { cause: caught });
 				lastFailure = caught;
-				await this.#waitBeforeRetry(attempt, null, input.signal);
+				await this.#waitBeforeRetry(attempt, null, overall?.signal ?? input.signal);
 			}
 		}
 		throw new DesignError("TASK_READ_FAILED", "Task status could not be read within the retry bound", { cause: lastFailure });
 	}
+	/** Wait for one bounded server observation; does not submit or sleep between snapshots. */
+	async waitTask(input) {
+		return this.readTask({
+			...input,
+			waitSeconds: input.timeoutSeconds ?? 30,
+			maxAttempts: input.maxAttempts ?? 1
+		});
+	}
 	async #waitBeforeRetry(attempt, retryAfter, signal) {
 		const delay = Math.min(MAX_INLINE_RETRY_DELAY_MS, Math.max(retryAfter ?? 0, 250 * 2 ** (attempt - 1)));
 		this.#log({
@@ -5480,6 +5582,11 @@ var DesignHostController = class {
 	#catalogNotice = null;
 	#catalogCredentialEpoch = null;
 	#pollCursor = 0;
+	#pollInFlight;
+	#pollAbort;
+	#pollEpoch;
+	#observationTail = Promise.resolve();
+	#serializeObservation;
 	constructor(options) {
 		this.#repository = new DesignTaskRepository({ storage: options.storage });
 		this.#resolveCredential = options.resolveCredential;
@@ -5490,6 +5597,11 @@ var DesignHostController = class {
 		this.#rememberModel = options.rememberModel;
 		this.#fetch = options.fetch ?? globalThis.fetch;
 		this.#now = options.now ?? Date.now;
+		this.#serializeObservation = options.serializeObservation ?? ((operation) => {
+			const run = this.#observationTail.then(operation);
+			this.#observationTail = run.catch(() => void 0);
+			return run;
+		});
 	}
 	async handle(endpoint, payload, signal) {
 		signal?.throwIfAborted();
@@ -5509,32 +5621,59 @@ var DesignHostController = class {
 		if (!this.#isEnabled()) return false;
 		const credential = await this.#resolveCredential();
 		if (credential === void 0) return false;
+		if (this.#pollEpoch !== credential.credentialEpoch) this.invalidateWaits();
+		if (this.#pollInFlight !== void 0) return this.#pollInFlight;
+		const abort = new AbortController();
+		this.#pollAbort = abort;
+		this.#pollEpoch = credential.credentialEpoch;
+		const combined = signal === void 0 ? abort.signal : AbortSignal.any([signal, abort.signal]);
+		const run = this.#waitRunning(credential, combined);
+		this.#pollInFlight = run;
+		try {
+			return await run;
+		} finally {
+			if (this.#pollInFlight === run) {
+				this.#pollInFlight = void 0;
+				this.#pollAbort = void 0;
+			}
+		}
+	}
+	invalidateWaits() {
+		this.#pollAbort?.abort();
+		this.#pollAbort = void 0;
+		this.#pollInFlight = void 0;
+		this.#pollEpoch = void 0;
+	}
+	async #waitRunning(credential, signal) {
 		const eligible = (await this.#repository.listTasks()).filter((task) => task.taskId !== null && task.credentialEpoch === credential.credentialEpoch && !task.pollBlocked && (task.state === "queued" || task.state === "running" || task.state === "unknown")).filter((task) => task.nextPollAt <= this.#now()).sort((left, right) => left.createdAt - right.createdAt || String(left.taskId).localeCompare(String(right.taskId)));
 		const start = eligible.length === 0 ? 0 : this.#pollCursor % eligible.length;
 		const batch = circularSlice(eligible, start, 5);
 		this.#pollCursor = eligible.length === 0 ? 0 : (start + batch.length) % eligible.length;
-		for (const record of batch) {
-			if (!this.#isCredentialEpochCurrent(credential.credentialEpoch)) break;
+		await Promise.all(batch.map(async (record) => {
+			if (!this.#isCredentialEpochCurrent(credential.credentialEpoch)) return;
 			try {
-				const task = await new PredictionClient({ fetch: this.#fetch }).readTask({
+				const task = await new PredictionClient({ fetch: this.#fetch }).waitTask({
 					taskId: record.taskId,
 					apiKey: credential.value,
 					maxAttempts: 1,
 					...signal === void 0 ? {} : { signal }
 				});
-				await this.#repository.recordTaskObserved(task);
+				await this.#serializeObservation(async () => {
+					if (!signal.aborted && this.#isCredentialEpochCurrent(credential.credentialEpoch)) await this.#repository.recordTaskObserved(task);
+				});
 			} catch (error) {
 				if (signal?.aborted === true) throw error;
 				const failure = classifyPollFailure(error, record.pollAttempt + 1, this.#now());
-				await this.#repository.recordPollFailure(record.taskId, failure);
+				await this.#serializeObservation(async () => {
+					if (!signal.aborted && this.#isCredentialEpochCurrent(credential.credentialEpoch)) await this.#repository.recordPollFailure(record.taskId, failure);
+				});
 				await this.#markUnauthorized(error, credential.credentialEpoch);
 			}
-		}
+		}));
 		return (await this.#repository.listTasks()).some((task) => task.credentialEpoch === credential.credentialEpoch && !task.pollBlocked && (task.state === "queued" || task.state === "running" || task.state === "unknown"));
 	}
 	async read(input, signal) {
 		const session = this.#session(input.sessionId);
-		if (this.#isEnabled()) await this.pollRunning(signal);
 		const models = await this.#loadModelsSafely(signal);
 		if (session.selectedModelId === null && models.length > 0) {
 			const modelId = chooseDefaultModel(models, this.#getLastModel());
@@ -6563,7 +6702,7 @@ function createSchemaTool(controller) {
 function createUploadFileTool(client, resolveCredential) {
 	return defineTool({
 		name: MODELLIX_MEDIA_UPLOAD_FILE_TOOL,
-		description: "Upload one image from the current conversation or session workspace to Modellix and return a temporary URL for media model inputs. Supply exactly one of attachment_id or path. Reuse returned URLs and never retry an unknown upload outcome automatically.",
+		description: "Upload an image attachment from this conversation or a supported image, video, or audio file inside the session workspace. Maximum 16 MiB (16777216 bytes). Supply exactly one of attachment_id or path. Reuse returned URLs and never retry an unknown upload outcome automatically. On quota errors, explicitly select unneeded files for deletion; never clean up automatically.",
 		parameters: {
 			attachment_id: {
 				type: "string",
@@ -6571,7 +6710,7 @@ function createUploadFileTool(client, resolveCredential) {
 			},
 			path: {
 				type: "string",
-				description: "Image path inside the current session workspace."
+				description: "Image, video, or audio path inside the current session workspace."
 			}
 		},
 		output: {
@@ -7955,6 +8094,7 @@ var ModellixRuntime = class ModellixRuntime {
 			mutate: (operations, expectedRevision) => this.#ctx.settings.mutate(LLM_SETTINGS_NAMESPACE, operations, expectedRevision)
 		});
 		this.#design = new DesignHostController({
+			serializeObservation: (operation) => this.enqueueDesignWrite(operation),
 			storage: designStorage,
 			resolveCredential: () => this.resolveUsableCredential(),
 			isCredentialEpochCurrent: (epoch) => epoch === this.#credential.credentialEpoch,
@@ -7974,6 +8114,7 @@ var ModellixRuntime = class ModellixRuntime {
 		this.#ctx.effect(() => this.#settings.watch((next, previous) => {
 			if (this.#closing) return void 0;
 			this.#config = next;
+			if (next.credentialEpoch !== previous.credentialEpoch || !next.services.design.enabled) this.#design.invalidateWaits();
 			this.#catalog.invalidate();
 			if (next.services.design.enabled !== previous.services.design.enabled) {
 				this.syncDesignTools(next.services.design.enabled);
@@ -8031,6 +8172,7 @@ var ModellixRuntime = class ModellixRuntime {
 			return async () => {
 				this.#closing = true;
 				this.#lifecycleAbort.abort();
+				this.#design.invalidateWaits();
 				this.#disposeDesignTools?.();
 				this.#disposeDesignTools = void 0;
 				if (this.#designPollTimer !== void 0) clearTimeout(this.#designPollTimer);
@@ -8689,7 +8831,10 @@ var ModellixRuntime = class ModellixRuntime {
 				handle: (endpoint, payload, signal) => {
 					const operationSignal = signal === void 0 ? this.#lifecycleAbort.signal : AbortSignal.any([signal, this.#lifecycleAbort.signal]);
 					if (designEndpointRequestsCredential(endpoint) && !this.credentialIsUsable()) this.requestCredentialRecovery();
-					return this.enqueueDesignWrite(() => this.#design.handle(endpoint, payload, operationSignal));
+					return this.enqueueDesignWrite(() => this.#design.handle(endpoint, payload, operationSignal)).then((snapshot) => {
+						this.scheduleDesignPoll(0);
+						return snapshot;
+					});
 				}
 			});
 			return;
@@ -8731,7 +8876,7 @@ var ModellixRuntime = class ModellixRuntime {
 		if (this.#closing || this.#designPollTimer !== void 0) return;
 		this.#designPollTimer = setTimeout(() => {
 			this.#designPollTimer = void 0;
-			this.enqueueDesignWrite(() => this.#design.pollRunning(this.#lifecycleAbort.signal)).then((hasRunning) => {
+			this.#design.pollRunning(this.#lifecycleAbort.signal).then((hasRunning) => {
 				if (hasRunning) this.scheduleDesignPoll(5e3);
 			}).catch(() => {
 				if (!this.#closing) this.scheduleDesignPoll(15e3);