omnius 1.0.190 → 1.0.191

package/dist/index.js

@@ -2859,7 +2859,7 @@ var init_security_classifier = __esm({
       // ── Network reads (safe)
       { match: /^(web_search|web_fetch)$/, info: NETWORK_READ },
       // ── Network outbound (mutating or remote inference)
-      { match: /^(image_generate|generate_image|generate_audio|generate_tts|create_audio_file|vision|video_understand|telegram_send_file)$/, info: NETWORK_OUTBOUND },
+      { match: /^(image_generate|generate_image|generate_audio|generate_model|generate_tts|create_audio_file|vision|video_understand|telegram_send_file)$/, info: NETWORK_OUTBOUND },
       { match: /^(transcribe_file|transcribe_url|youtube_download)$/, info: NETWORK_OUTBOUND },
       { match: /^(fortemi_bridge)$/, info: NETWORK_OUTBOUND },
       // ── Memory tools
@@ -9996,8 +9996,11 @@ var init_explore_tools = __esm({
       desktop_describe: "Describe a region of the desktop",
       transcribe_file: "Transcribe audio/video files to text",
       telegram_media_recent: "List recent Telegram media available in the current chat scope",
+      hf_model_discover: "Search Hugging Face for image/video/audio/3D/CAD model adapters",
+      hf_model_intake: "Inspect, validate, save, list, or delete Hugging Face media model adapters",
       generate_audio: "Generate sound effects or music with local model backends",
       generate_tts: "Generate speech from text with configured voice/TTS backends",
+      generate_model: "Generate or check 3D/CAD model requests using the /models Hugging Face catalog",
       create_tool: "Create a new custom tool from a workflow",
       manage_tools: "List, inspect, or remove custom tools",
       skill_list: "List available AIWG skills",
@@ -267026,6 +267029,423 @@ ${llmAnnotation}` : result.llmContent;
   }
 });
 
+// packages/execution/dist/tools/model-generate.js
+function normalizeAction(value2) {
+  const raw = String(value2 ?? "generate").trim().toLowerCase().replace(/-/g, "_");
+  if (raw === "list" || raw === "models" || raw === "list_models")
+    return "list_models";
+  if (raw === "check" || raw === "setup" || raw === "prepare" || raw === "select")
+    return "check";
+  return "generate";
+}
+function rankCatalogEntries(kind) {
+  return listMediaModelCatalog(kind).sort((a2, b) => {
+    const exact = Number(a2.spec.modality !== kind) - Number(b.spec.modality !== kind);
+    if (exact !== 0)
+      return exact;
+    const active = statusRank(a2.spec.status) - statusRank(b.spec.status);
+    if (active !== 0)
+      return active;
+    const runtime = Number(!a2.spec.deployment.runtimeCompatible) - Number(!b.spec.deployment.runtimeCompatible);
+    if (runtime !== 0)
+      return runtime;
+    const download = (a2.spec.resources.approxDownloadGB ?? 9999) - (b.spec.resources.approxDownloadGB ?? 9999);
+    if (download !== 0)
+      return download;
+    return a2.spec.id.localeCompare(b.spec.id);
+  });
+}
+function statusRank(status) {
+  if (status === "active")
+    return 0;
+  if (status === "metadata-only")
+    return 1;
+  if (status === "draft")
+    return 2;
+  return 3;
+}
+function renderCatalogForKind(kind, entries) {
+  if (entries.length === 0)
+    return `No ${kindLabel(kind)} model adapters are available.`;
+  const lines = [`Available ${kindLabel(kind)} model adapters:`];
+  for (const entry of entries) {
+    const spec = entry.spec;
+    const resources = resourceSummary(spec);
+    lines.push(`- ${spec.id} [${spec.modality}/${spec.backend}/${spec.status}${resources ? `, ${resources}` : ""}] - ${spec.label}`);
+  }
+  lines.push("");
+  lines.push("Call generate_model with action='check' to see disk/resource readiness, or action='generate' to attempt generation when a runtime adapter is wired.");
+  return lines.join("\n");
+}
+function renderReadiness(kind, spec, readiness) {
+  const lines = [
+    `${kindLabel(kind)} generation model: ${spec.id}`,
+    `Status: ${readiness.ok ? "ready" : "blocked"}`,
+    `Backend: ${spec.backend}`,
+    `Runner: ${spec.runner}`,
+    `Resources: ${resourceSummary(spec) || "unknown"}`,
+    `Disk: ${readiness.disk.reason}`
+  ];
+  if (readiness.notes.length > 0) {
+    lines.push("Notes:");
+    for (const note of readiness.notes)
+      lines.push(`- ${note}`);
+  }
+  if (readiness.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const warning of readiness.warnings)
+      lines.push(`- ${warning}`);
+  }
+  if (readiness.blockers.length > 0) {
+    lines.push("Blockers:");
+    for (const blocker of readiness.blockers)
+      lines.push(`- ${blocker}`);
+  }
+  if (spec.deployment.notes.length > 0) {
+    lines.push("Deployment notes:");
+    for (const note of spec.deployment.notes.slice(0, 4))
+      lines.push(`- ${note}`);
+  }
+  return lines.join("\n");
+}
+function modelSummary(entry) {
+  const spec = entry.spec;
+  return {
+    id: spec.id,
+    repoId: spec.repoId,
+    label: spec.label,
+    modality: spec.modality,
+    modalities: spec.modalities,
+    backend: spec.backend,
+    runner: spec.runner,
+    status: spec.status,
+    resources: spec.resources,
+    requiresToken: spec.deployment.requiresToken,
+    runtimeCompatible: spec.deployment.runtimeCompatible,
+    safeRunner: spec.deployment.safeRunner,
+    outputKind: spec.smokeTest.outputKind
+  };
+}
+function checkDisk(spec) {
+  const disk = getModelStoreDiskInfo();
+  const approxGb = spec.resources.approxDownloadGB ?? spec.smokeTest.maxDownloadGB;
+  if (!approxGb || approxGb <= 0) {
+    return {
+      ok: true,
+      reason: `${formatBytes(disk.freeBytes)} free on ${disk.path}; model download size is unknown.`,
+      freeBytes: disk.freeBytes,
+      totalBytes: disk.totalBytes
+    };
+  }
+  const neededBytes = gigabytesToBytes(approxGb);
+  const safetyMargin = 1 * 1024 ** 3;
+  const ok3 = disk.freeBytes >= neededBytes + safetyMargin;
+  return {
+    ok: ok3,
+    reason: ok3 ? `${formatBytes(disk.freeBytes)} free; ${spec.id} needs about ${formatBytes(neededBytes)} plus 1.0GB headroom.` : `${formatBytes(disk.freeBytes)} free; ${spec.id} needs about ${formatBytes(neededBytes)} plus 1.0GB headroom.`,
+    neededBytes,
+    freeBytes: disk.freeBytes,
+    totalBytes: disk.totalBytes
+  };
+}
+function modelLoadSpecFor(spec, kind) {
+  return {
+    name: spec.id,
+    domain: domainForKind(kind),
+    host: hostForBackend(spec.backend),
+    owner: "generate_model",
+    estimatedVramMB: gbToMb(spec.resources.minVramGB),
+    estimatedRamMB: gbToMb(spec.resources.minRamGB),
+    priority: 5
+  };
+}
+function domainForKind(kind) {
+  return kind === "cad" ? "cad" : "3d-gen";
+}
+function hostForBackend(backend) {
+  if (backend === "diffusers")
+    return "diffusers-py";
+  if (backend === "comfyui")
+    return "comfyui";
+  if (backend === "project" || backend === "generated")
+    return "subprocess";
+  return "hf-local";
+}
+function gbToMb(gb) {
+  if (typeof gb !== "number" || !Number.isFinite(gb))
+    return void 0;
+  return Math.max(0, Math.round(gb * 1024));
+}
+function resourceSummary(spec) {
+  const parts = [];
+  if (spec.resources.approxDownloadGB !== void 0)
+    parts.push(`~${spec.resources.approxDownloadGB}GB download`);
+  if (spec.resources.minVramGB !== void 0)
+    parts.push(`min ${spec.resources.minVramGB}GB VRAM`);
+  if (spec.resources.recommendedVramGB !== void 0)
+    parts.push(`rec ${spec.resources.recommendedVramGB}GB VRAM`);
+  if (spec.resources.minRamGB !== void 0)
+    parts.push(`min ${spec.resources.minRamGB}GB RAM`);
+  if (spec.deployment.requiresToken)
+    parts.push("HF token/license required");
+  return parts.join(", ");
+}
+function kindLabel(kind) {
+  return kind === "cad" ? "CAD" : "3D model";
+}
+var RUNTIME_BLOCKER, ModelGenerateTool;
+var init_model_generate = __esm({
+  "packages/execution/dist/tools/model-generate.js"() {
+    "use strict";
+    init_model_broker();
+    init_hf_media_models();
+    init_model_store();
+    RUNTIME_BLOCKER = "No 3D/CAD generation runtime is wired yet for this catalog adapter, so no artifact was created.";
+    ModelGenerateTool = class {
+      cwd;
+      name = "generate_model";
+      description = "Generate or prepare 3D/CAD models from prompts or input images. Use this for text-to-CAD, text-to-3D, image-to-3D, mesh, GLB, OBJ, STL, PLY, SCAD, or STEP requests. It exposes the same Hugging Face 3D/CAD catalog used by /models, checks disk/resource fit, and returns explicit runtime blockers instead of silently failing.";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["generate", "list_models", "check", "setup"],
+            description: "generate attempts a model-generation run; list_models shows selectable 3D/CAD adapters; check reports model, disk, and resource readiness."
+          },
+          kind: {
+            type: "string",
+            enum: ["3d", "cad"],
+            description: "Use '3d' for mesh/asset/world generation and 'cad' for parametric/mechanical CAD."
+          },
+          prompt: {
+            type: "string",
+            description: "Text prompt describing the desired 3D asset or CAD part."
+          },
+          model: {
+            type: "string",
+            description: "Optional Hugging Face repo/model id. Defaults to the configured /models selection or the smallest fitting catalog candidate."
+          },
+          backend: {
+            type: "string",
+            description: "Optional backend filter such as diffusers, transformers, onnx, project, or generated."
+          },
+          input_image: {
+            type: "string",
+            description: "Optional local image path for image-to-3D reconstruction models."
+          },
+          input: {
+            type: "string",
+            description: "Optional local image/video path or upstream artifact path for reconstruction models."
+          },
+          output_format: {
+            type: "string",
+            enum: ["glb", "obj", "stl", "ply", "scad", "step", "png", "json"],
+            description: "Desired output artifact format when the selected runtime supports it."
+          },
+          output_path: {
+            type: "string",
+            description: "Optional output file path for the generated artifact."
+          }
+        },
+        required: []
+      };
+      progressCallback = null;
+      defaults;
+      constructor(cwd4 = process.cwd(), defaults3 = {}) {
+        this.cwd = cwd4;
+        this.defaults = defaults3;
+      }
+      setDefaults(defaults3) {
+        this.defaults = defaults3;
+      }
+      setProgressCallback(handler) {
+        this.progressCallback = handler;
+      }
+      async execute(args) {
+        const start2 = performance.now();
+        const action = normalizeAction(args["action"]);
+        const kind = this.normalizeKind(args);
+        try {
+          if (action === "list_models") {
+            const entries = rankCatalogEntries(kind);
+            return {
+              success: true,
+              output: renderCatalogForKind(kind, entries),
+              llmContent: JSON.stringify(entries.map((entry) => modelSummary(entry)), null, 2),
+              durationMs: performance.now() - start2
+            };
+          }
+          const selected = this.selectModel(kind, args);
+          if (!selected) {
+            return {
+              success: false,
+              output: "",
+              error: `No ${kindLabel(kind)} model adapter is available. Use hf_model_discover or hf_model_intake to add one.`,
+              durationMs: performance.now() - start2
+            };
+          }
+          const spec = selected.spec;
+          this.emit(start2, "setup", `Selected ${spec.id} (${spec.modality}/${spec.backend})`, 10);
+          const readiness = await this.checkReadiness(spec, kind);
+          const body = renderReadiness(kind, spec, readiness);
+          if (action === "check") {
+            return {
+              success: true,
+              output: body,
+              llmContent: JSON.stringify({ model: modelSummary(selected), readiness }, null, 2),
+              durationMs: performance.now() - start2
+            };
+          }
+          const prompt = String(args["prompt"] ?? "").trim();
+          const input = String(args["input_image"] ?? args["input"] ?? "").trim();
+          if (!prompt && !input) {
+            return {
+              success: false,
+              output: `${body}
+
+No artifact created: provide prompt and/or input_image for ${kindLabel(kind)} generation.`,
+              error: `prompt or input_image is required for ${kindLabel(kind)} generation`,
+              llmContent: JSON.stringify({ model: modelSummary(selected), readiness, created: false, reason: "missing_prompt_or_input" }, null, 2),
+              durationMs: performance.now() - start2
+            };
+          }
+          this.emit(start2, "load", RUNTIME_BLOCKER, 100);
+          const output = [
+            body,
+            "",
+            RUNTIME_BLOCKER,
+            "Use this tool result as the user-facing blocker. Do not claim that a GLB/OBJ/STL/SCAD/STEP file was generated."
+          ].join("\n");
+          return {
+            success: false,
+            output,
+            error: RUNTIME_BLOCKER,
+            llmContent: JSON.stringify({
+              model: modelSummary(selected),
+              readiness,
+              created: false,
+              reason: "runtime_not_wired",
+              prompt,
+              input,
+              cwd: this.cwd
+            }, null, 2),
+            durationMs: performance.now() - start2
+          };
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: err instanceof Error ? err.message : String(err),
+            durationMs: performance.now() - start2
+          };
+        }
+      }
+      normalizeKind(args) {
+        const rawKind = String(args["kind"] ?? "").trim().toLowerCase();
+        if (rawKind === "cad" || rawKind.includes("cad") || rawKind.includes("step") || rawKind.includes("scad"))
+          return "cad";
+        if (rawKind === "3d" || rawKind.includes("mesh") || rawKind.includes("model") || rawKind.includes("world"))
+          return "3d";
+        const outputFormat = String(args["output_format"] ?? "").trim().toLowerCase();
+        if (outputFormat === "scad" || outputFormat === "step")
+          return "cad";
+        if (outputFormat === "glb" || outputFormat === "obj" || outputFormat === "stl" || outputFormat === "ply")
+          return "3d";
+        const modelId = String(args["model"] ?? "").trim();
+        if (modelId) {
+          const entry = resolveMediaModel(modelId);
+          if (entry?.spec.modality === "cad")
+            return "cad";
+          if (entry?.spec.modality === "3d")
+            return "3d";
+        }
+        return "3d";
+      }
+      selectModel(kind, args) {
+        const requested = String(args["model"] ?? "").trim();
+        const configured = kind === "cad" ? this.defaults.cadModel : this.defaults.model3dModel;
+        const model = requested || configured || "";
+        if (model)
+          return resolveMediaModel(model, kind);
+        const requestedBackend = String(args["backend"] ?? "").trim();
+        const backend = requestedBackend || (kind === "cad" ? this.defaults.cadBackend : this.defaults.model3dBackend);
+        const entries = rankCatalogEntries(kind);
+        if (backend && backend !== "auto") {
+          const wantedBackend = backend.toLowerCase();
+          const matching = entries.find((entry) => entry.spec.backend === wantedBackend);
+          if (matching)
+            return matching;
+        }
+        return entries[0];
+      }
+      async checkReadiness(spec, kind) {
+        const blockers = [];
+        const warnings = [];
+        const notes2 = [];
+        const disk = checkDisk(spec);
+        if (!disk.ok)
+          blockers.push(disk.reason);
+        else
+          notes2.push(disk.reason);
+        const broker = getModelBroker();
+        const loadSpec = modelLoadSpecFor(spec, kind);
+        let brokerDecision = { kind: "unknown" };
+        let clearInflight = false;
+        try {
+          const decision2 = await broker.ensureModelLoadable(loadSpec);
+          clearInflight = decision2.kind === "ok";
+          if (decision2.kind === "wait-for-inflight") {
+            brokerDecision = { kind: "wait-for-inflight" };
+            warnings.push(`Another load for ${spec.id} is already in flight.`);
+          } else if (decision2.kind === "ok") {
+            brokerDecision = { kind: "ok", gpuIndex: decision2.gpuIndex ?? null, note: decision2.note };
+            notes2.push(decision2.note ? `Resource broker accepted ${spec.id}: ${decision2.note}.` : `Resource broker accepted ${spec.id}.`);
+          } else if (decision2.kind === "evict") {
+            brokerDecision = { kind: "evict", evictTargets: decision2.evictTargets.map((m2) => `${m2.host}:${m2.name}`), gpuIndex: decision2.gpuIndex ?? null };
+            warnings.push(`Resource broker would need to evict ${decision2.evictTargets.length} loaded model(s) before loading ${spec.id}.`);
+          } else if (decision2.kind === "degrade") {
+            brokerDecision = { kind: "degrade", fallback: decision2.fallback.name, reason: decision2.reason };
+            warnings.push(`Resource broker would degrade ${spec.id} to ${decision2.fallback.name}: ${decision2.reason}.`);
+          } else {
+            brokerDecision = { kind: "reject", reason: decision2.reason };
+            blockers.push(`Resource broker rejected ${spec.id}: ${decision2.reason}.`);
+          }
+        } catch (err) {
+          const message2 = err instanceof Error ? err.message : String(err);
+          warnings.push(`Resource broker check failed: ${message2}`);
+        } finally {
+          if (clearInflight)
+            broker.clearInflight(loadSpec.host, loadSpec.name);
+        }
+        if (spec.deployment.requiresToken) {
+          blockers.push(`${spec.id} requires a Hugging Face token/license acceptance before download.`);
+        }
+        if (!spec.deployment.runtimeCompatible || !spec.deployment.safeRunner) {
+          blockers.push(`${spec.id} has catalog metadata but no trusted built-in runtime adapter.`);
+        }
+        blockers.push(RUNTIME_BLOCKER);
+        return {
+          ok: blockers.length === 0,
+          blockers,
+          warnings,
+          notes: notes2,
+          disk,
+          brokerDecision
+        };
+      }
+      emit(start2, stage, message2, percent) {
+        this.progressCallback?.({
+          stage,
+          message: message2,
+          percent,
+          elapsedMs: performance.now() - start2
+        });
+      }
+    };
+  }
+});
+
 // packages/execution/dist/tools/sponsor-media.js
 import { createHash as createHash8 } from "node:crypto";
 function normalizeSponsorMediaConfig(value2) {
@@ -532003,6 +532423,7 @@ __export(dist_exports, {
   MemoryWriteTool: () => MemoryWriteTool,
   MeshtasticTool: () => MeshtasticTool,
   ModelBroker: () => ModelBroker,
+  ModelGenerateTool: () => ModelGenerateTool,
   MultimodalMemoryTool: () => MultimodalMemoryTool,
   NetworkEgressPolicyError: () => NetworkEgressPolicyError,
   NexusTool: () => NexusTool,
@@ -532372,6 +532793,7 @@ var init_dist5 = __esm({
     init_cuda_device_filter();
     init_model_store();
     init_video_generate();
+    init_model_generate();
     init_sponsor_media();
     init_structured_read();
     init_vision();
@@ -551450,7 +551872,8 @@ var init_agenticRunner = __esm({
       "visual_memory",
       "desktop_describe",
       "ocr_pdf",
-      "generate_image"
+      "generate_image",
+      "generate_model"
     ]);
     AUDIO_TOOLS = /* @__PURE__ */ new Set([
       "audio_capture",
@@ -561180,7 +561603,7 @@ ${marker}` : marker);
        */
       toolResultEventContent(toolName, output) {
         const displayOutput = this.unwrapToolOutputForDisplay(output);
-        if (toolName === "generate_image" || toolName === "generate_audio" || toolName === "generate_video" || toolName === "generate_tts" || toolName === "create_audio_file" || toolName === "screenshot" || toolName === "camera_capture" || /(?:Image generated|Music generated|Sound generated|Video generated|Screenshot saved|Saved to|Output saved to):?\s+/i.test(displayOutput)) {
+        if (toolName === "generate_image" || toolName === "generate_audio" || toolName === "generate_video" || toolName === "generate_model" || toolName === "generate_tts" || toolName === "create_audio_file" || toolName === "screenshot" || toolName === "camera_capture" || /(?:Image generated|Music generated|Sound generated|Video generated|3D model generated|CAD generated|Model generated|Screenshot saved|Saved to|Output saved to):?\s+/i.test(displayOutput)) {
           return displayOutput.slice(0, 2e3);
         }
         return displayOutput.slice(0, 200);
@@ -569853,12 +570276,13 @@ function generationKindForToolName(toolName) {
   if (toolName === "generate_image") return "image";
   if (toolName === "generate_audio") return "audio";
   if (toolName === "generate_video") return "video";
+  if (toolName === "generate_model") return "model";
   if (toolName === "generate_tts" || toolName === "create_audio_file") return "tts";
   return null;
 }
 function formatGenerativeProgress(kind, event, options2 = {}) {
   const width = Math.max(8, Math.min(32, options2.width ?? (options2.surface === "telegram" ? 12 : 20)));
-  const label = kindLabel(kind);
+  const label = kindLabel2(kind);
   const stage = stageLabel(event.stage);
   const pct = finitePercent(event.percent);
   const bytes = formatProgressBytes(event);
@@ -569871,8 +570295,9 @@ function formatGenerativeProgress(kind, event, options2 = {}) {
   }
   return `${label} ${stage}: ${message2}${bytes}${elapsed}`;
 }
-function kindLabel(kind) {
+function kindLabel2(kind) {
   if (kind === "tts") return "TTS";
+  if (kind === "model") return "3D/CAD";
   return kind.slice(0, 1).toUpperCase() + kind.slice(1);
 }
 function stageLabel(stage) {
@@ -626471,6 +626896,7 @@ var init_tool_policy = __esm({
       "telegram",
       "generate_image",
       "generate_audio",
+      "generate_model",
       "generate_tts",
       "create_audio_file",
       "telegram_send_file",
@@ -626503,6 +626929,7 @@ var init_tool_policy = __esm({
       "telegram",
       "generate_image",
       "generate_audio",
+      "generate_model",
       "generate_tts",
       "create_audio_file",
       "telegram_send_file",
@@ -627484,7 +627911,7 @@ function formatTelegramCreativeWorkspacePrompt(root) {
     "Allowed: create and send non-executable creative artifacts in this workspace.",
     "At rest, artifacts are stored as random internal blobs with random header bytes; requested filenames are logical names restored only during Telegram upload.",
     "Forbidden: delete files, create scripts/executables, access paths outside this workspace, mutate the project tree, run shell/Python/code commands, or touch system state.",
-    "Freshly generated/created artifacts are recorded for automatic Telegram attachment when the turn completes. Do not call telegram_send_file for the same fresh artifact unless the user asked for a specific caption, existing/unrecorded file, or non-default target. Refer to the attachment naturally; do not expose filesystem paths unless the admin explicitly asks."
+    "Freshly generated/created artifacts, including image/audio/video/3D/CAD outputs, are recorded for automatic Telegram attachment when the turn completes. Do not call telegram_send_file for the same fresh artifact unless the user asked for a specific caption, existing/unrecorded file, or non-default target. Refer to the attachment naturally; do not expose filesystem paths unless the admin explicitly asks."
   ].join("\n");
 }
 function publicCreativeArtifactPolicyError(path12) {
@@ -627514,7 +627941,7 @@ function collectGeneratedArtifactPathsFromText(text, root) {
     }
   }
   for (const line of text.split(/\r?\n/)) {
-    const marker = line.match(/(?:Image generated|Sound generated|Music generated|Video generated|TTS generated|Created [A-Z]+ file|Created|Overwrote|Saved to):\s*([^\n\r(]+)/i);
+    const marker = line.match(/(?:Image generated|Sound generated|Music generated|Video generated|3D model generated|CAD generated|Model generated|TTS generated|Created [A-Z]+ file|Created|Overwrote|Saved to):\s*([^\n\r(]+)/i);
     const value2 = marker?.[1]?.trim().replace(/^["']|["']$/g, "");
     if (!value2) continue;
     const guarded = guardPath(rootAbs, value2);
@@ -627524,7 +627951,7 @@ function collectGeneratedArtifactPathsFromText(text, root) {
   }
   return [...paths];
 }
-function buildTelegramCreativeTools(repoRoot, chatId, backendUrl2, imageDefaults = {}, audioDefaults = {}, videoDefaults = {}) {
+function buildTelegramCreativeTools(repoRoot, chatId, backendUrl2, imageDefaults = {}, audioDefaults = {}, videoDefaults = {}, modelDefaults = {}) {
   const root = telegramCreativeWorkspaceRoot(repoRoot, chatId);
   ensureManifest(root);
   return [
@@ -627535,6 +627962,7 @@ function buildTelegramCreativeTools(repoRoot, chatId, backendUrl2, imageDefaults
     scopedTool(new AudioGenerateTool(root, audioDefaults), root, "generate"),
     scopedTool(new TtsGenerateTool(), root, "generate"),
     scopedTool(new VideoGenerateTool(root, videoDefaults), root, "generate"),
+    scopedTool(new ModelGenerateTool(root, modelDefaults), root, "generate"),
     new CreativeAudioFileTool(root)
   ];
 }
@@ -627546,7 +627974,7 @@ function scopedTool(base3, root, mode) {
     parameters: base3.parameters,
     async execute(args) {
       const next = { ...args };
-      if (base3.name === "generate_image" || base3.name === "generate_audio" || base3.name === "generate_tts" || base3.name === "generate_video") {
+      if (base3.name === "generate_image" || base3.name === "generate_audio" || base3.name === "generate_tts" || base3.name === "generate_video" || base3.name === "generate_model") {
         const cleanup = [];
         const localModel = typeof next["model_path"] === "string" ? String(next["model_path"]) : typeof next["model"] === "string" && looksLikeLocalPath(String(next["model"])) ? String(next["model"]) : "";
         if (localModel) {
@@ -627566,6 +627994,26 @@ function scopedTool(base3, root, mode) {
             if (materialized.cleanup) cleanup.push(materialized.cleanup);
           }
         }
+        if (base3.name === "generate_model") {
+          for (const key of MODEL_INPUT_PATH_KEYS) {
+            const value2 = next[key];
+            if (typeof value2 !== "string" || !value2.trim()) continue;
+            if (/^https?:\/\//i.test(value2.trim())) continue;
+            const materialized = materializeTelegramCreativeArtifactForSend(rootAbs, value2.trim());
+            if (!materialized.ok) return denied(materialized.error);
+            next[key] = materialized.path;
+            if (materialized.cleanup) cleanup.push(materialized.cleanup);
+          }
+          const output = typeof next["output_path"] === "string" && String(next["output_path"]).trim() ? String(next["output_path"]) : typeof next["output"] === "string" && String(next["output"]).trim() ? String(next["output"]) : "";
+          if (output) {
+            const guardedOutput = guardPath(rootAbs, output);
+            if (!guardedOutput.ok) return denied(guardedOutput.error);
+            if (existsSync121(guardedOutput.path.abs) && !manifestHas(rootAbs, guardedOutput.path.rel)) {
+              return denied(`Refusing to overwrite a file that is not owned by this chat workspace manifest: ${guardedOutput.path.rel}`);
+            }
+            next["output_path"] = guardedOutput.path.abs;
+          }
+        }
         if (base3.name === "generate_tts") {
           for (const key of TTS_CLONE_SOURCE_KEYS) {
             const value2 = next[key];
@@ -627876,7 +628324,7 @@ function denied(error) {
     mutatedFiles: []
   };
 }
-var MANIFEST_FILE, OBJECTS_DIR, SEND_DIR, PATH_KEYS, TTS_CLONE_SOURCE_KEYS, VIDEO_IMAGE_INPUT_KEYS, MEDIA_PATH_RE, PUBLIC_EXECUTABLE_ARTIFACT_EXTENSIONS, CreativeAudioFileTool;
+var MANIFEST_FILE, OBJECTS_DIR, SEND_DIR, PATH_KEYS, TTS_CLONE_SOURCE_KEYS, VIDEO_IMAGE_INPUT_KEYS, MODEL_INPUT_PATH_KEYS, MEDIA_PATH_RE, PUBLIC_EXECUTABLE_ARTIFACT_EXTENSIONS, CreativeAudioFileTool;
 var init_telegram_creative_tools = __esm({
   "packages/cli/src/tui/telegram-creative-tools.ts"() {
     "use strict";
@@ -627887,6 +628335,7 @@ var init_telegram_creative_tools = __esm({
     PATH_KEYS = ["path", "file", "file_path", "filename", "filepath", "filePath"];
     TTS_CLONE_SOURCE_KEYS = ["sample", "source_audio", "voice_sample", "reference_audio", "ref_audio", "clone_sample"];
     VIDEO_IMAGE_INPUT_KEYS = ["image", "image_path", "init_image", "source_image", "reference_image"];
+    MODEL_INPUT_PATH_KEYS = ["input", "input_image", "image", "image_path", "source_image", "reference_image"];
     MEDIA_PATH_RE = /(?:^|[\s([])(\/[^\s<>"')\]]+\.[A-Za-z0-9]{1,12})(?:$|[\s),.\]])/g;
     PUBLIC_EXECUTABLE_ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Set([
       ".sh",
@@ -633007,6 +633456,10 @@ When asked to generate speech, narration, or TTS, use generate_tts or audio_play
 Those tools handle first-use backend setup where supported. Do not fall back to shell
 commands or generic audio generation for speech synthesis while those tools are available.
 
+When asked to generate a 3D asset, mesh, printable model, or CAD part, use
+generate_model. Use hf_model_discover or hf_model_intake only when the admin is
+asking to add, inspect, validate, or save model adapters.
+
 Keep responses concise for Telegram but don't withhold information from the admin.
 `.trim();
     ADMIN_GROUP_PROMPT = `
@@ -640797,9 +641250,10 @@ ${currentTelegramPrompt}`;
             "You have the full scoped Telegram media-analysis stack by default: telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. For complex textual imagery, screenshots, forms, scans, or dense labels, prefer ocr_image_advanced after resolving media with path='reply' or path='latest'.",
             formatIdentityMemoryContext(chatLabel || "Telegram private chat"),
             reminderToolContract,
-            "If the user asks you to create an image, audio file, video, or document artifact, create it with the scoped creative tools. Freshly generated artifacts are recorded and automatically attached to this Telegram chat when the turn completes, so do not call telegram_send_file for those same artifacts unless the user asked for a specific caption, existing/unrecorded file, or non-default target.",
+            "If the user asks you to create an image, audio file, video, 3D/CAD model, or document artifact, create it with the scoped creative tools. Freshly generated artifacts are recorded and automatically attached to this Telegram chat when the turn completes, so do not call telegram_send_file for those same artifacts unless the user asked for a specific caption, existing/unrecorded file, or non-default target.",
             "For image generation requests, decide from the conversation whether generate_image is appropriate; do not ask the user to use a hardcoded shortcut when the request is clear.",
             "For video generation requests, decide whether generate_video is appropriate. Use mode='i2v' (image-to-video) when the user references an attached or already-generated image; otherwise mode='t2v'. Warn the user up front that video generation typically takes 2-10 minutes on consumer GPUs, and that the public Telegram video-generation quota is tight (2/hour/user).",
+            "For 3D asset, mesh, printable model, or CAD generation requests, use generate_model. Use kind='cad' for parametric/mechanical parts and kind='3d' for mesh/asset/world requests. If the tool reports a catalog/runtime blocker, explain that blocker plainly.",
             creativeWorkspace
           ].filter(Boolean).join("\n\n");
           userPrompt = `${systemPrompt}${discretionPrompt}
@@ -641487,6 +641941,7 @@ Scoped workspace: ${scopedRoot}`,
         const imageDefaults = this.imageGenerationDefaultsForRepo(repoRoot);
         const audioDefaults = this.audioGenerationDefaultsForRepo(repoRoot);
         const videoDefaults = this.videoGenerationDefaultsForRepo(repoRoot);
+        const modelDefaults = this.modelGenerationDefaultsForRepo(repoRoot);
         const generativeProgress = this.createTelegramGenerativeProgressBridge(chatId, msg);
         const taskComplete = {
           name: "task_complete",
@@ -641605,6 +642060,7 @@ Scoped workspace: ${scopedRoot}`,
           new ImageGenerateTool(repoRoot, this.agentConfig?.backendUrl, imageDefaults),
           new AudioGenerateTool(repoRoot, audioDefaults),
           new VideoGenerateTool(repoRoot, videoDefaults),
+          new ModelGenerateTool(repoRoot, modelDefaults),
           new HfModelIntakeTool(),
           new HfModelDiscoverTool(),
           new TtsGenerateTool(),
@@ -641648,7 +642104,8 @@ Scoped workspace: ${scopedRoot}`,
             this.agentConfig?.backendUrl,
             imageDefaults,
             audioDefaults,
-            videoDefaults
+            videoDefaults,
+            modelDefaults
           ).map((tool) => adaptTool5(tool, todoSessionId, generativeProgress));
           adaptedTools.push(...creativeTools);
           adaptedTools.push(adaptTool5(this.buildTelegramSendFileTool(context2, repoRoot, chatId, msg), todoSessionId, generativeProgress));
@@ -641706,7 +642163,7 @@ Scoped workspace: ${scopedRoot}`,
         if (toolName === "web_fetch") return "web";
         if (/^(image_read|ocr|ocr_image_advanced|ocr_pdf|pdf_to_text|vision|transcribe_file|video_understand|audio_analyze)$/.test(toolName)) return "media";
         if (toolName === "generate_video") return "video-generation";
-        if (/^(generate_image|generate_audio|generate_tts|create_audio_file)$/.test(toolName)) return "generation";
+        if (/^(generate_image|generate_audio|generate_model|generate_tts|create_audio_file)$/.test(toolName)) return "generation";
         if (toolName === "telegram_send_file") return "upload";
         if (/^(reminder|remind|reminders)$/.test(toolName)) return "reminder";
         return null;
@@ -643061,6 +643518,15 @@ Scoped workspace: ${scopedRoot}`,
           defaultKind: settings.videoKind
         };
       }
+      modelGenerationDefaultsForRepo(repoRoot) {
+        const settings = resolveSettings(repoRoot);
+        return {
+          cadModel: typeof settings.cadModel === "string" && settings.cadModel.trim() ? settings.cadModel : void 0,
+          cadBackend: settings.cadBackend,
+          model3dModel: typeof settings.model3dModel === "string" && settings.model3dModel.trim() ? settings.model3dModel : void 0,
+          model3dBackend: settings.model3dBackend
+        };
+      }
       buildTelegramSendFileTool(context2, repoRoot, currentChatId, currentMsg) {
         const bridge = this;
         const adminDm = context2 === "telegram-admin-dm";
@@ -670267,6 +670733,18 @@ function videoGenerationDefaultsForRepo(repoRoot) {
 function createConfiguredVideoGenerateTool(repoRoot) {
   return new VideoGenerateTool(repoRoot, videoGenerationDefaultsForRepo(repoRoot));
 }
+function modelGenerationDefaultsForRepo(repoRoot) {
+  const settings = resolveSettings(repoRoot);
+  return {
+    cadModel: typeof settings.cadModel === "string" && settings.cadModel.trim() ? settings.cadModel : void 0,
+    cadBackend: settings.cadBackend,
+    model3dModel: typeof settings.model3dModel === "string" && settings.model3dModel.trim() ? settings.model3dModel : void 0,
+    model3dBackend: settings.model3dBackend
+  };
+}
+function createConfiguredModelGenerateTool(repoRoot) {
+  return new ModelGenerateTool(repoRoot, modelGenerationDefaultsForRepo(repoRoot));
+}
 function buildSubAgentTools(repoRoot, config) {
   return [
     // File + search
@@ -670366,6 +670844,7 @@ function buildSubAgentTools(repoRoot, config) {
     createConfiguredImageGenerateTool(repoRoot, config.backendUrl),
     createConfiguredAudioGenerateTool(repoRoot),
     createConfiguredVideoGenerateTool(repoRoot),
+    createConfiguredModelGenerateTool(repoRoot),
     // Hardware sensors + radios (read-only scans)
     new GpsLocationTool(),
     new WifiControlTool(),
@@ -670455,6 +670934,8 @@ function buildTools(repoRoot, config, contextWindowSize, modelTier) {
     createConfiguredAudioGenerateTool(repoRoot),
     // Video Generation — local Diffusers/ComfyUI video pipelines
     createConfiguredVideoGenerateTool(repoRoot),
+    // 3D/CAD Generation — Hugging Face catalog-backed model readiness surface
+    createConfiguredModelGenerateTool(repoRoot),
     // Structured file reading (CSV, JSON, Markdown, binary detection)
     new StructuredReadTool(repoRoot),
     // Vision tools (Moondream — desktop awareness + point-and-click)

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.190",
+  "version": "1.0.191",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.190",
+      "version": "1.0.191",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.190",
+  "version": "1.0.191",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",