@mcoda/mswarm 0.1.134 → 0.1.135-codali.2

package/dist/vendor/codali/connectors/media/ConfiguredMediaTools.js

@@ -0,0 +1,41 @@
+import { setTimeout as delay } from "node:timers/promises";
+export const mediaJobSummary = (job) => ({ id: job.id, operation: job.operation, status: job.status, model: job.modelId, configHash: job.configHash, cancelRequested: job.cancelRequested, remote: job.remote, error: job.error, artifact: job.artifact });
+export const createConfiguredMediaTools = (resolved, store) => {
+    const properties = { prompt: { type: "string", minLength: 1 }, negative_prompt: { type: "string" }, size: { type: "string" }, seed: { type: "integer" }, steps: { type: "integer", minimum: 1 }, high_noise_steps: { type: "integer", minimum: 1 }, duration_seconds: { type: "number", minimum: 0 }, fps: { type: "integer", minimum: 1 }, video_frames: { type: "integer", minimum: 1 }, sample_rate: { type: "integer", minimum: 1 } };
+    const tools = [];
+    for (const [binding, operation] of [["image", "images.generations"], ["audio", "audio.generations"], ["video", "videos.generations"]])
+        if (resolved.config.bindings[binding]?.enabled !== false && resolved.config.bindings[binding])
+            tools.push({
+                name: `media_generate_${binding}`, description: `Submit a ${binding} generation job using the approved model configuration. Returns a durable job ID; use media_job_wait to obtain its artifact. Never resubmit uncertain jobs.`, capability: "media", readOnly: false,
+                inputSchema: { type: "object", properties, required: ["prompt"], additionalProperties: false },
+                handler: async (args, context) => { const data = mediaJobSummary(await store().submit(resolved, binding, operation, args, context.signal)); return { output: JSON.stringify(data), data }; },
+            });
+    for (const action of ["status", "wait", "cancel"])
+        tools.push({
+            name: `media_job_${action}`, description: `${action} a durable media job. Wait suspends locally without additional model calls and reports progress; cancelling a wait leaves the render running. An uncertain remote outcome must be reconciled before another submission.`, capability: "media", readOnly: action !== "cancel", inputSchema: { type: "object", properties: { jobId: { type: "string" }, ...(action === "wait" ? { waitSeconds: { type: "integer", minimum: 1, maximum: 600 } } : {}) }, required: ["jobId"], additionalProperties: false },
+            handler: async (args, context) => {
+                const id = args.jobId;
+                if (action === "cancel") {
+                    const data = mediaJobSummary(await store().cancel(id));
+                    return { output: JSON.stringify(data), data };
+                }
+                let job = await store().reconcileProcess(id, context.signal);
+                const waitSeconds = args.waitSeconds ?? 300;
+                const until = Date.now() + waitSeconds * 1000;
+                let lastProgress = 0;
+                while (action === "wait" && ["queued", "running"].includes(job.status) && Date.now() < until) {
+                    context.signal?.throwIfAborted();
+                    if (Date.now() - lastProgress >= 5000) {
+                        context.onOutput?.("stdout", `Media ${id}: ${job.status}\n`);
+                        lastProgress = Date.now();
+                    }
+                    await delay(Math.min(500, Math.max(1, until - Date.now())), undefined, { signal: context.signal });
+                    job = await store().reconcileProcess(id, context.signal);
+                }
+                const data = mediaJobSummary(job);
+                return { output: JSON.stringify(data), data };
+            },
+        });
+    tools.push({ name: "media_export_artifact", description: "Copy a completed, checksum-verified media artifact to a new workspace file. Requires workspace write permission and a claimed task scope.", capability: "workspace", readOnly: false, inputSchema: { type: "object", properties: { jobId: { type: "string" }, path: { type: "string" } }, required: ["jobId", "path"], additionalProperties: false }, handler: async (args, context) => { const { jobId, path } = args; const data = await store().exportArtifact(jobId, context.workspaceRoot, path, resolvedPath => context.checkPath?.(resolvedPath, "write") ?? Promise.resolve()); context.recordTouchedFile?.(path); return { output: JSON.stringify(data), data }; } });
+    return tools;
+};

package/dist/vendor/codali/connectors/media/ImageGenerationTool.js

@@ -31,9 +31,9 @@ export const createImageGenerationTool = (options) => {
         name: IMAGE_TOOL_NAME,
         description: "Generate an image from a text prompt. Returns the path to the written image file, not the image itself. Use for any request to draw, render, or generate a picture.",
         capability: "media",
-        // Generation writes a file, but only inside the run's own artifact
-        // directory — it cannot touch the workspace or anything the user owns.
-        readOnly: true,
+        // Generation consumes compute and writes an artifact, so it requires
+        // explicit media permission even when the artifact directory is private.
+        readOnly: false,
         inputSchema: {
             type: "object",
             required: ["prompt"],

package/dist/vendor/codali/connectors/media/MediaArtifactReceipt.d.ts

@@ -0,0 +1,5 @@
+import type { MediaArtifact, MediaJob } from "./MediaJobStore.js";
+/** Persist received output before acknowledging success; never resubmit inference during recovery. */
+export declare const persistMediaArtifact: (directory: string, job: MediaJob, bytes: Buffer) => Promise<MediaArtifact>;
+export declare const recoverMediaArtifact: (directory: string, job: MediaJob) => Promise<MediaArtifact | undefined>;
+//# sourceMappingURL=MediaArtifactReceipt.d.ts.map

package/dist/vendor/codali/connectors/media/MediaArtifactReceipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaArtifactReceipt.d.ts","sourceRoot":"","sources":["../../../src/connectors/media/MediaArtifactReceipt.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAUlE,sGAAsG;AACtG,eAAO,MAAM,oBAAoB,GAAU,WAAW,MAAM,EAAE,KAAK,QAAQ,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,aAAa,CAejH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,WAAW,MAAM,EAAE,KAAK,QAAQ,KAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAY9G,CAAC"}

package/dist/vendor/codali/connectors/media/MediaArtifactReceipt.js

@@ -0,0 +1,65 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { atomicWriteJson, syncStateDirectory } from "../../session/AtomicState.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const format = (job) => job.operation === "images.generations" ? { extension: "png", mimeType: "image/png" }
+    : job.operation === "audio.generations" ? { extension: "wav", mimeType: "audio/wav" }
+        : job.operation === "videos.generations" ? { extension: "webm", mimeType: "video/webm" } : undefined;
+const matchesFormat = (bytes, extension) => extension === "png" ? bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
+    : extension === "wav" ? bytes.subarray(0, 4).toString() === "RIFF" && bytes.subarray(8, 12).toString() === "WAVE"
+        : bytes.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]));
+/** Persist received output before acknowledging success; never resubmit inference during recovery. */
+export const persistMediaArtifact = async (directory, job, bytes) => {
+    const media = format(job);
+    if (!media || bytes.length > 67108864 || !matchesFormat(bytes, media.extension))
+        throw new Error("Media file format or size does not match the advertised contract");
+    const artifact = { id: `${job.id}-artifact`, jobId: job.id, path: path.join(directory, `artifact.${media.extension}`), mimeType: media.mimeType,
+        bytes: bytes.length, sha256: hash(bytes), model: job.modelId, configHash: job.configHash, createdAt: new Date().toISOString() };
+    await atomicWriteJson(path.join(directory, "artifact-receipt.json"), { schemaVersion: 1, sessionId: job.sessionId, artifact });
+    const temporary = path.join(directory, `.artifact-${randomUUID()}.partial`);
+    const handle = await fs.open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+        await handle.close();
+        // link is atomic and fails if the destination exists; a partially written artifact is never published.
+        await fs.link(temporary, artifact.path);
+        await syncStateDirectory(directory);
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+        await fs.unlink(temporary).catch(() => undefined);
+    }
+    return artifact;
+};
+export const recoverMediaArtifact = async (directory, job) => {
+    let receipt;
+    try {
+        receipt = JSON.parse(await fs.readFile(path.join(directory, "artifact-receipt.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    const media = format(job);
+    const artifact = receipt.artifact;
+    if (!media || receipt.schemaVersion !== 1 || receipt.sessionId !== job.sessionId || artifact.jobId !== job.id || artifact.id !== `${job.id}-artifact` || artifact.configHash !== job.configHash || artifact.model !== job.modelId || artifact.mimeType !== media.mimeType || artifact.path !== path.join(directory, `artifact.${media.extension}`))
+        throw new Error("Media artifact receipt does not match this job");
+    let stat;
+    try {
+        stat = await fs.lstat(artifact.path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    if (!stat.isFile() || stat.size !== artifact.bytes || stat.size > 67108864)
+        throw new Error("Media artifact receipt size or path is invalid");
+    const bytes = await fs.readFile(artifact.path);
+    if (hash(bytes) !== artifact.sha256 || !matchesFormat(bytes, media.extension))
+        throw new Error("Media artifact receipt checksum or format mismatch");
+    return artifact;
+};

package/dist/vendor/codali/connectors/media/MediaJobStore.d.ts

@@ -0,0 +1,68 @@
+import { type ModelOperation, type ResolvedOrchestrationConfig } from "../../config/OrchestrationConfig.js";
+export interface MediaArtifact {
+    id: string;
+    jobId: string;
+    path: string;
+    mimeType: string;
+    bytes: number;
+    sha256: string;
+    model: string;
+    configHash: string;
+    createdAt: string;
+}
+export interface MediaJob {
+    schemaVersion: 1;
+    id: string;
+    sessionId: string;
+    operation: ModelOperation;
+    binding: string;
+    modelId: string;
+    catalogId: string;
+    providerId: string;
+    configHash: string;
+    resolved: ResolvedOrchestrationConfig;
+    request: Record<string, unknown>;
+    status: "queued" | "running" | "succeeded" | "failed" | "cancelled" | "uncertain";
+    createdAt: string;
+    updatedAt: string;
+    pid?: number;
+    cancelRequested?: boolean;
+    error?: string;
+    artifact?: MediaArtifact;
+    reconciliation?: {
+        at: string;
+        outcome: "failed";
+        note: string;
+    };
+    remote?: {
+        protocol: "mswarm-media-jobs-v1";
+        submissionStartedAt: string;
+        jobId?: string;
+        invocationId?: string;
+        status?: string;
+        nodeId?: string;
+        expiresAt?: string;
+        resultSha256?: string;
+        acknowledgedAt?: string;
+        cancelRequested?: boolean;
+        cancelConfirmed?: boolean;
+        usage?: Record<string, unknown>;
+    };
+}
+export declare class MediaJobStore {
+    readonly root: string;
+    readonly sessionId: string;
+    constructor(root: string, sessionId: string);
+    file(id: string): string;
+    read(id: string): Promise<MediaJob>;
+    update(id: string, mutate: (job: MediaJob) => void): Promise<MediaJob>;
+    list(): Promise<MediaJob[]>;
+    submit(resolved: ResolvedOrchestrationConfig, binding: string, operation: ModelOperation, request: Record<string, unknown>, signal?: AbortSignal): Promise<MediaJob>;
+    cancel(id: string): Promise<MediaJob>;
+    /** Trusted user/host action, deliberately unavailable as an agent tool. */
+    reconcileFailure(id: string, note: string): Promise<MediaJob>;
+    reconcileProcess(id: string, signal?: AbortSignal): Promise<MediaJob>;
+    exportArtifact(id: string, workspaceRoot: string, destination: string, checkPath?: (resolvedPath: string) => Promise<void>): Promise<MediaArtifact>;
+}
+export declare const validateMediaRequest: (request: Record<string, unknown>, descriptor: Record<string, unknown>, operation: ModelOperation) => Record<string, unknown>;
+//# sourceMappingURL=MediaJobStore.d.ts.map

package/dist/vendor/codali/connectors/media/MediaJobStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaJobStore.d.ts","sourceRoot":"","sources":["../../../src/connectors/media/MediaJobStore.ts"],"names":[],"mappings":"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"}

package/dist/vendor/codali/connectors/media/MediaJobStore.js

@@ -0,0 +1,199 @@
+import { randomUUID, createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { atomicWriteJson, tryStateLock, withStateLock } from "../../session/AtomicState.js";
+import { pinOrchestrationConfig } from "../../config/OrchestrationConfig.js";
+import { ConfiguredProvider } from "../../providers/ConfiguredProvider.js";
+import { recoverMediaArtifact } from "./MediaArtifactReceipt.js";
+import { reconcileRemoteMediaJob } from "./RemoteMediaJob.js";
+const validId = (id) => { if (!/^[a-zA-Z0-9-]{1,120}$/.test(id))
+    throw new Error("Invalid media job id"); return id; };
+export class MediaJobStore {
+    constructor(root, sessionId) {
+        this.root = root;
+        this.sessionId = sessionId;
+        validId(sessionId);
+    }
+    file(id) { return path.join(this.root, validId(id), "job.json"); }
+    async read(id) {
+        const job = JSON.parse(await fs.readFile(this.file(id), "utf8"));
+        if (job.schemaVersion !== 1 || job.sessionId !== this.sessionId || job.id !== id)
+            throw new Error("Media job belongs to another session");
+        return job;
+    }
+    async update(id, mutate) {
+        return withStateLock(this.file(id), async () => { const job = await this.read(id); mutate(job); job.updatedAt = new Date().toISOString(); await atomicWriteJson(this.file(id), job); return job; });
+    }
+    async list() {
+        let names;
+        try {
+            names = await fs.readdir(this.root);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const jobs = [];
+        for (const id of names) {
+            if (!/^[a-zA-Z0-9-]{1,120}$/.test(id))
+                continue;
+            const job = await this.read(id);
+            jobs.push(job);
+        }
+        return jobs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    async submit(resolved, binding, operation, request, signal) {
+        resolved = pinOrchestrationConfig(resolved);
+        if ((await this.list()).some(job => ["queued", "running", "uncertain"].includes(job.status)))
+            throw new Error("Resolve the active or uncertain media job before submitting another render in this session");
+        const selected = await new ConfiguredProvider(resolved, binding).select(operation, signal);
+        const descriptor = selected.actual.raw.operations?.find(v => v.type === operation);
+        if (!descriptor)
+            throw new Error("The service did not advertise this media operation contract");
+        const body = validateMediaRequest(request, descriptor, operation);
+        signal?.throwIfAborted();
+        const at = new Date().toISOString();
+        const id = randomUUID();
+        const job = { schemaVersion: 1, id, sessionId: this.sessionId, operation, binding, modelId: selected.id, catalogId: selected.model.catalogId, providerId: selected.model.provider, configHash: resolved.hash, resolved, request: { ...body, model: selected.model.catalogId }, status: "queued", createdAt: at, updatedAt: at };
+        await withStateLock(path.join(this.root, ".submission"), async () => {
+            if ((await this.list()).some(existing => ["queued", "running", "uncertain"].includes(existing.status)))
+                throw new Error("Resolve the active or uncertain media job before submitting another render in this session");
+            await atomicWriteJson(this.file(id), job);
+        });
+        const credentialName = selected.provider.credentialRef?.slice(4);
+        const env = { PATH: process.env.PATH, HOME: process.env.HOME, LANG: process.env.LANG };
+        if (credentialName && process.env[credentialName])
+            env[credentialName] = process.env[credentialName];
+        try {
+            const child = spawn(process.execPath, [fileURLToPath(new URL("./MediaJobWorker.js", import.meta.url)), this.root, this.sessionId, id], { detached: true, stdio: "ignore", env });
+            child.unref();
+            child.once("error", () => { void this.update(id, state => { state.status = "failed"; state.error = "Media worker could not start"; }).catch(() => undefined); });
+            await this.update(id, state => { state.pid = child.pid; });
+        }
+        catch {
+            await this.update(id, state => { state.status = "failed"; state.error = "Media worker could not start"; });
+        }
+        return this.read(id);
+    }
+    async cancel(id) {
+        return this.update(id, job => { if (!["succeeded", "failed", "cancelled"].includes(job.status))
+            job.cancelRequested = true; });
+    }
+    /** Trusted user/host action, deliberately unavailable as an agent tool. */
+    async reconcileFailure(id, note) {
+        if (!note.trim() || note.length > 4000)
+            throw new Error("Describe the confirmed remote failure or cancellation (1–4000 characters)");
+        return this.update(id, job => {
+            if (job.status !== "uncertain")
+                throw new Error("Only an uncertain media job needs manual reconciliation");
+            job.status = "failed";
+            job.reconciliation = { at: new Date().toISOString(), outcome: "failed", note };
+            job.error = "Remote failure/cancellation confirmed by user; see reconciliation record";
+        });
+    }
+    async reconcileProcess(id, signal) {
+        signal?.throwIfAborted();
+        const job = await this.read(id);
+        if (["succeeded", "failed", "cancelled"].includes(job.status) || job.status === "queued" && Date.now() - Date.parse(job.createdAt) <= 60000)
+            return job;
+        const recovery = await tryStateLock(`${this.file(id)}.execution`, async () => {
+            const current = await this.read(id);
+            if (["succeeded", "failed", "cancelled"].includes(current.status))
+                return current;
+            let artifact;
+            let failure;
+            try {
+                artifact = await recoverMediaArtifact(path.dirname(this.file(id)), current);
+            }
+            catch (error) {
+                failure = error instanceof Error ? error.message : "Artifact recovery failed";
+            }
+            if (!artifact && !failure && current.remote) {
+                try {
+                    return await reconcileRemoteMediaJob(this, current, signal);
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    failure = error instanceof Error ? error.message : "Remote media recovery failed";
+                }
+            }
+            return this.update(id, state => {
+                if (["succeeded", "failed", "cancelled"].includes(state.status))
+                    return;
+                if (artifact) {
+                    state.status = "succeeded";
+                    state.artifact = artifact;
+                    state.error = undefined;
+                }
+                else {
+                    state.status = "uncertain";
+                    state.error = failure ?? "Media worker stopped without a complete local receipt; remote execution may have occurred. Do not resubmit automatically.";
+                }
+            });
+        });
+        return recovery.acquired ? recovery.value : job;
+    }
+    async exportArtifact(id, workspaceRoot, destination, checkPath) {
+        const job = await this.read(id);
+        const artifact = job.artifact;
+        if (job.status !== "succeeded" || !artifact)
+            throw new Error("Media artifact is not ready");
+        const target = path.resolve(workspaceRoot, destination);
+        const root = await fs.realpath(workspaceRoot);
+        const parent = await fs.realpath(path.dirname(target));
+        if (parent !== root && !parent.startsWith(`${root}${path.sep}`))
+            throw new Error("Artifact destination escapes the workspace");
+        const canonicalTarget = path.join(parent, path.basename(target));
+        if ([".git", ".mcoda"].includes(path.relative(root, canonicalTarget).split(path.sep)[0]))
+            throw new Error("Artifact cannot overwrite repository control metadata");
+        await checkPath?.(canonicalTarget);
+        const bytes = await fs.readFile(artifact.path);
+        if (createHash("sha256").update(bytes).digest("hex") !== artifact.sha256)
+            throw new Error("Artifact checksum mismatch");
+        await fs.writeFile(canonicalTarget, bytes, { flag: "wx", mode: 0o600 });
+        return { ...artifact, path: canonicalTarget };
+    }
+}
+export const validateMediaRequest = (request, descriptor, operation) => {
+    const allowlist = descriptor.supported_parameters;
+    if (!Array.isArray(allowlist))
+        throw new Error("Missing advertised media parameters");
+    for (const name of Object.keys(request))
+        if (!allowlist.includes(name) || ["model", "response_format", "n"].includes(name))
+            throw new Error(`Unsupported media parameter: ${name}`);
+    const limits = (descriptor.limits ?? {});
+    if (typeof request.prompt !== "string" || !request.prompt.trim() || request.prompt.length > (limits.max_prompt_chars ?? 8192))
+        throw new Error("Invalid media prompt length");
+    const body = { ...request, n: 1, response_format: operation === "images.generations" ? "b64_json" : operation === "audio.generations" ? "wav" : "webm" };
+    if (!descriptor.response_formats?.includes(body.response_format))
+        throw new Error("Required media output format is not supported");
+    for (const name of ["steps", "high_noise_steps", "duration_seconds", "sample_rate", "fps", "video_frames"]) {
+        const value = request[name];
+        if (value === undefined)
+            continue;
+        if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || (name !== "duration_seconds" && !Number.isInteger(value)))
+            throw new Error(`Invalid media ${name}`);
+        if (limits[`min_${name}`] !== undefined && value < limits[`min_${name}`] || limits[`max_${name}`] !== undefined && value > limits[`max_${name}`])
+            throw new Error(`Media ${name} exceeds advertised limits`);
+    }
+    if (request.size !== undefined) {
+        if (typeof request.size !== "string" || !/^\d+x\d+$/.test(request.size))
+            throw new Error("Invalid media size");
+        const [width, height] = request.size.split("x").map(Number);
+        for (const [name, value] of [["width", width], ["height", height]])
+            if (value < (limits[`min_${name}`] ?? 1) || value > (limits[`max_${name}`] ?? 4096))
+                throw new Error(`Media ${name} exceeds advertised limits`);
+        if (width * height > (limits.max_pixels ?? 16777216))
+            throw new Error("Media pixel count exceeds advertised limit");
+    }
+    if (typeof request.negative_prompt === "string" && request.negative_prompt.length > (limits.max_negative_prompt_chars ?? 8192))
+        throw new Error("Negative prompt too long");
+    if (request.seed !== undefined && (typeof request.seed !== "number" || !Number.isSafeInteger(request.seed)))
+        throw new Error("Invalid seed");
+    if (Buffer.byteLength(JSON.stringify(body)) > (limits.max_request_bytes ?? 131072))
+        throw new Error("Media request exceeds byte limit");
+    return body;
+};

package/dist/vendor/codali/connectors/media/MediaJobWorker.d.ts

@@ -0,0 +1,2 @@
+export declare const executeMediaJob: (root: string, sessionId: string, id: string) => Promise<void>;
+//# sourceMappingURL=MediaJobWorker.d.ts.map

package/dist/vendor/codali/connectors/media/MediaJobWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaJobWorker.d.ts","sourceRoot":"","sources":["../../../src/connectors/media/MediaJobWorker.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe,GAAU,MAAM,MAAM,EAAE,WAAW,MAAM,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CA+B/F,CAAC"}

package/dist/vendor/codali/connectors/media/MediaJobWorker.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ModelServiceClient } from "../../providers/ConfiguredProvider.js";
+import { ModelServiceError } from "../../providers/ModelServiceError.js";
+import { MediaJobStore } from "./MediaJobStore.js";
+import { withStateLock } from "../../session/AtomicState.js";
+import { persistMediaArtifact } from "./MediaArtifactReceipt.js";
+import { pinOrchestrationConfig, resolveBinding } from "../../config/OrchestrationConfig.js";
+import { executeRemoteMediaJob } from "./RemoteMediaJob.js";
+export const executeMediaJob = async (root, sessionId, id) => {
+    const store = new MediaJobStore(root, sessionId);
+    // A worker crash releases no success claim and never automatically resubmits.
+    await withStateLock(`${store.file(id)}.execution`, async () => {
+        const job = await store.read(id);
+        if (job.status !== "queued")
+            return;
+        if (job.cancelRequested) {
+            await store.update(id, state => { state.status = "failed"; state.error = "Cancelled before submission"; });
+            return;
+        }
+        try {
+            job.resolved = pinOrchestrationConfig(job.resolved);
+            const model = job.resolved.config.models[job.modelId];
+            if (job.configHash !== job.resolved.hash || model?.provider !== job.providerId || model?.catalogId !== job.catalogId || job.request.model !== job.catalogId || !resolveBinding(job.resolved.config, job.binding, job.operation).some(candidate => candidate.id === job.modelId))
+                throw new Error("Media job route does not match its pinned configuration");
+        }
+        catch (error) {
+            await store.update(id, state => { state.status = "failed"; state.error = error instanceof Error ? error.message : "Invalid media configuration"; });
+            return;
+        }
+        await store.update(id, state => { state.status = "running"; state.pid = process.pid; });
+        const abort = new AbortController();
+        let checking = false;
+        const durable = !!job.resolved.config.providers[job.providerId].mediaJobsUrl;
+        const timer = setInterval(() => { if (checking || durable)
+            return; checking = true; void store.read(id).then(state => { if (state.cancelRequested)
+            abort.abort(new Error("Cancellation requested; remote termination is unconfirmed")); }).catch(error => abort.abort(error)).finally(() => { checking = false; }); }, 500);
+        try {
+            const provider = job.resolved.config.providers[job.providerId];
+            if (durable) {
+                await executeRemoteMediaJob(store, job);
+                return;
+            }
+            const endpoint = `${provider.baseUrl.replace(/\/$/, "")}/${job.operation.replace(".", "/")}`;
+            const response = await new ModelServiceClient(provider).json(endpoint, { method: "POST", body: job.request, signal: abort.signal, timeoutMs: 60 * 60 * 1000 });
+            const payload = response.data?.[0];
+            const base64 = payload?.b64_json ?? payload?.b64_audio ?? payload?.b64_video;
+            if (typeof base64 !== "string" || !base64 || base64.length > 89478488 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64))
+                throw new Error("Invalid or oversized media payload");
+            const bytes = Buffer.from(base64, "base64");
+            const artifact = await persistMediaArtifact(path.dirname(store.file(id)), job, bytes);
+            await store.update(id, state => { state.status = "succeeded"; state.artifact = artifact; });
+        }
+        catch (error) {
+            const rejected = error instanceof ModelServiceError && [400, 401, 402, 403, 404, 405, 413, 415, 422, 429].includes(error.status);
+            await store.update(id, state => { state.status = rejected && !state.remote ? "failed" : "uncertain"; state.error = error instanceof Error ? error.message : "Media submission outcome is unknown"; });
+        }
+        finally {
+            clearInterval(timer);
+        }
+    });
+};
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    executeMediaJob(process.argv[2], process.argv[3], process.argv[4]).catch(() => { process.exitCode = 1; });
+}

package/dist/vendor/codali/connectors/media/RemoteMediaJob.d.ts

@@ -0,0 +1,6 @@
+import type { MediaJob, MediaJobStore } from "./MediaJobStore.js";
+/** This path only reads/cancels/acknowledges a known client job id. It never
+ * submits again, including after a lost admission response or process crash. */
+export declare const reconcileRemoteMediaJob: (store: MediaJobStore, job: MediaJob, signal?: AbortSignal) => Promise<MediaJob>;
+export declare const executeRemoteMediaJob: (store: MediaJobStore, job: MediaJob) => Promise<void>;
+//# sourceMappingURL=RemoteMediaJob.d.ts.map

package/dist/vendor/codali/connectors/media/RemoteMediaJob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteMediaJob.d.ts","sourceRoot":"","sources":["../../../src/connectors/media/RemoteMediaJob.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA2BlE;gFACgF;AAChF,eAAO,MAAM,uBAAuB,GAAU,OAAO,aAAa,EAAE,KAAK,QAAQ,EAAE,SAAS,WAAW,KAAG,OAAO,CAAC,QAAQ,CA2BzH,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAU,OAAO,aAAa,EAAE,KAAK,QAAQ,KAAG,OAAO,CAAC,IAAI,CAgB7F,CAAC"}

package/dist/vendor/codali/connectors/media/RemoteMediaJob.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { ModelServiceClient } from "../../providers/ConfiguredProvider.js";
+import { pinOrchestrationConfig, resolveBinding } from "../../config/OrchestrationConfig.js";
+import { persistMediaArtifact } from "./MediaArtifactReceipt.js";
+const connection = (job) => {
+    const resolved = pinOrchestrationConfig(job.resolved);
+    const provider = resolved.config.providers[job.providerId];
+    const model = resolved.config.models[job.modelId];
+    if (!provider?.mediaJobsUrl || resolved.hash !== job.configHash || job.request.model !== job.catalogId || model?.provider !== job.providerId || model?.catalogId !== job.catalogId || !resolveBinding(resolved.config, job.binding, job.operation).some(candidate => candidate.id === job.modelId))
+        throw new Error("Remote media job does not match its pinned configuration");
+    return { client: new ModelServiceClient(provider), url: `${provider.mediaJobsUrl.replace(/\/$/, "")}/${job.id}` };
+};
+const receipt = (job, value) => {
+    const v = value;
+    if (!v || v.protocol !== "mswarm-media-jobs-v1" || v.client_id !== job.id || typeof v.job_id !== "string" || !/^shj_media_[a-f0-9]{64}$/.test(v.job_id) || v.operation !== job.operation || v.model !== job.catalogId || !["admitting", "queued", "running", "succeeded", "failed", "cancelled", "uncertain", "expired"].includes(v.status))
+        throw new Error("Remote media receipt identity or contract mismatch");
+    if (job.remote?.jobId && job.remote.jobId !== v.job_id)
+        throw new Error("Remote media job identity changed");
+    if (v.status === "cancelled" && v.cancel_confirmed !== true)
+        throw new Error("The service has not confirmed media cancellation");
+    return v;
+};
+const saveReceipt = (store, job, remote) => store.update(job.id, state => {
+    if (!state.remote)
+        throw new Error("Missing remote submission intent");
+    Object.assign(state.remote, { jobId: remote.job_id, invocationId: remote.invocation_id ?? undefined, status: remote.status, nodeId: remote.node_id ?? undefined, expiresAt: remote.expires_at ?? undefined, resultSha256: remote.result_sha256, cancelRequested: remote.cancel_requested === true, cancelConfirmed: remote.cancel_confirmed === true, usage: remote.usage });
+});
+/** This path only reads/cancels/acknowledges a known client job id. It never
+ * submits again, including after a lost admission response or process crash. */
+export const reconcileRemoteMediaJob = async (store, job, signal) => {
+    const { client, url } = connection(job);
+    if (job.cancelRequested && !job.remote?.cancelRequested) {
+        const cancelled = receipt(job, await client.json(url, { method: "DELETE", signal }));
+        job = await saveReceipt(store, job, cancelled);
+    }
+    const remote = receipt(job, await client.json(`${url}?result=1`, { signal }));
+    job = await saveReceipt(store, job, remote);
+    if (remote.status === "succeeded") {
+        if (!remote.result || typeof remote.result_sha256 !== "string" || createHash("sha256").update(JSON.stringify(remote.result)).digest("hex") !== remote.result_sha256)
+            throw new Error("Remote media result checksum mismatch");
+        const data = remote.result.data?.[0];
+        const base64 = data?.b64_json ?? data?.b64_audio ?? data?.b64_video;
+        if (typeof base64 !== "string" || !base64 || base64.length > 89478488 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64))
+            throw new Error("Invalid or oversized media payload");
+        const artifact = await persistMediaArtifact(path.dirname(store.file(job.id)), job, Buffer.from(base64, "base64"));
+        // A local durable artifact precedes server acknowledgement. If ACK fails,
+        // the successful local receipt remains usable and the server TTL bounds it.
+        job = await store.update(job.id, current => { current.status = "succeeded"; current.artifact = artifact; current.error = undefined; });
+        try {
+            await client.json(`${url}/ack`, { method: "POST", body: { result_sha256: remote.result_sha256 }, signal });
+            job = await store.update(job.id, current => { current.remote.acknowledgedAt = new Date().toISOString(); });
+        }
+        catch { /* Do not downgrade a verified artifact after a lost ACK. */ }
+        return job;
+    }
+    return store.update(job.id, current => {
+        current.status = remote.status === "cancelled" ? "cancelled" : ["failed", "expired"].includes(remote.status) ? "failed" : remote.status === "uncertain" ? "uncertain" : "running";
+        current.error = remote.error ?? (remote.status === "uncertain" ? "Remote admission or execution is unresolved" : undefined);
+    });
+};
+export const executeRemoteMediaJob = async (store, job) => {
+    const { client, url } = connection(job);
+    if (!job.remote) {
+        // Persist before the first network byte. Recovery always uses GET, even
+        // when the process dies before it can store the server acknowledgement.
+        job = await store.update(job.id, current => { current.remote = { protocol: "mswarm-media-jobs-v1", submissionStartedAt: new Date().toISOString() }; });
+        const accepted = receipt(job, await client.json(url, { method: "PUT", body: { operation: job.operation, request: job.request } }));
+        job = await saveReceipt(store, job, accepted);
+    }
+    const deadline = Date.parse(job.remote.submissionStartedAt) + 60 * 60000;
+    while (Date.now() < deadline) {
+        job = await reconcileRemoteMediaJob(store, await store.read(job.id));
+        if (["succeeded", "failed", "cancelled", "uncertain"].includes(job.status))
+            return;
+        await delay(2000);
+    }
+    await store.update(job.id, current => { current.status = "uncertain"; current.error = "Media observation deadline elapsed; inspect the original remote job before further work"; });
+};