wave3d-agent-sdk 0.2.13 → 0.2.14

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdir as mkdir3, readFile as readFile2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile2, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import { execFile } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir2 } from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import JSZip from "jszip";
@@ -14,7 +14,7 @@ import MiniSearch2 from "minisearch";
 
 // ../../scripts/wavegenie-sdk/server.ts
 import { createServer } from "node:http";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { createReadStream } from "node:fs";
 
 // ../../src/lib/waveStudio/aiAssist/core/resultEnvelope.ts
@@ -182,10 +182,10 @@ var WaveGenieBridgeCommandBroker = class {
 };
 
 // ../../scripts/wavegenie-sdk/mcp.ts
-import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path2 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path3 from "node:path";
 
 // ../../wave-engine/dist/src/core/assetPipeline/registry/gaussianSplatAssetTypes.js
 var WAVE_GAUSSIAN_SPLAT_RUNTIME_ASSET_ROOT = "/defaultAssets/runtime/adobe-spz";
@@ -25422,12 +25422,12 @@ var Tools = class {
    * @param path defines the path to use
    * @returns the filename
    */
-  static GetFilename(path5) {
-    const index = path5.lastIndexOf("/");
+  static GetFilename(path6) {
+    const index = path6.lastIndexOf("/");
     if (index < 0) {
-      return path5;
+      return path6;
     }
-    return path5.substring(index + 1);
+    return path6.substring(index + 1);
   }
   /**
    * Extracts the "folder" part of a path (everything before the filename).
@@ -42520,8 +42520,8 @@ function normalizeWaveGenieAssetUploadRequest(request) {
 
 // ../../src/lib/waveStudio/aiAssist/bridge/localAgentSdkContract.ts
 var WAVE3D_AGENT_SDK_PACKAGE_NAME = "wave3d-agent-sdk";
-var WAVE3D_AGENT_SDK_REQUIRED_VERSION = "0.2.13";
-var WAVE3D_AGENT_SDK_REQUIRED_BUILD = "agent-sdk-20260625.1";
+var WAVE3D_AGENT_SDK_REQUIRED_VERSION = "0.2.14";
+var WAVE3D_AGENT_SDK_REQUIRED_BUILD = "agent-sdk-20260625.2";
 var WAVE3D_AGENT_SDK_PACKAGE_SPEC = `${WAVE3D_AGENT_SDK_PACKAGE_NAME}@${WAVE3D_AGENT_SDK_REQUIRED_VERSION}`;
 var WAVE3D_AGENT_SDK_START_COMMAND = `npx -y ${WAVE3D_AGENT_SDK_PACKAGE_SPEC} start`;
 var WAVE3D_AGENT_SDK_TOKEN_ENV_VAR = "WAVE3D_MCP_TOKEN";
@@ -42660,7 +42660,12 @@ var WAVE_MCP_TOOL_ALIAS_CANONICAL_NAMES = {
   mcp_status: "get_wave_mcp_health",
   get_mcp_health: "get_wave_mcp_health",
   get_mcp_status: "get_wave_mcp_health",
-  get_wave_mcp_status: "get_wave_mcp_health"
+  get_wave_mcp_status: "get_wave_mcp_health",
+  generate_wave_3d_model: "create_wave_3d_modeling_job",
+  create_wave_3d_model: "create_wave_3d_modeling_job",
+  create_wave_3d_model_from_screenshots: "create_wave_3d_modeling_job",
+  make_wave_3d_model_from_screenshot: "create_wave_3d_modeling_job",
+  scaffold_wave_3d_modeling_job: "create_wave_3d_modeling_job"
 };
 function canonicalizeWaveMcpToolName(toolName) {
   return WAVE_MCP_TOOL_ALIAS_CANONICAL_NAMES[toolName] ?? toolName;
@@ -42802,6 +42807,7 @@ var WAVE_MCP_TOOL_CONTRACTS = {
   get_wave_runtime_entity_snapshot: { workMode: "observe", domain: "runtime", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
   list_wave_runtime_markers: { workMode: "observe", domain: "marker", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
   capture_wave_screenshot: { workMode: "observe", domain: "visual", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
+  create_wave_3d_modeling_job: { workMode: "operate", domain: "modeling", safety: "workspaceOperation", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true, directIntentKind: "asset.manage", directEditIntent: "modifyAssets" },
   query_wave_api: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "none", requiresTaskRoute: true, supportsTaskRoute: true },
   edit_wave_file: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "exactPathRequired", requiresTaskRoute: true, supportsTaskRoute: true },
   apply_wave_patch: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "exactPathRequired", requiresTaskRoute: true, supportsTaskRoute: true },
@@ -42944,6 +42950,9 @@ var WAVE_MCP_ASSET_STAGING_STORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "get_wave_asset_upload_status",
   "abort_wave_asset_upload"
 ]);
+var WAVE_MCP_LOCAL_SDK_WORKSPACE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_wave_3d_modeling_job"
+]);
 function getWaveMcpToolExecutionScope(toolName) {
   const canonicalToolName = canonicalizeWaveMcpToolName(toolName);
   if (WAVE_MCP_SESSION_DISCOVERY_TOOL_NAMES.has(canonicalToolName)) return "sessionDiscovery";
@@ -42952,6 +42961,7 @@ function getWaveMcpToolExecutionScope(toolName) {
   if (WAVE_MCP_REFERENCE_LOOKUP_TOOL_NAMES.has(canonicalToolName)) return "referenceLookup";
   if (canonicalToolName === "get_wave_command_result") return "commandStatus";
   if (WAVE_MCP_ASSET_STAGING_STORE_TOOL_NAMES.has(canonicalToolName)) return "assetStagingStore";
+  if (WAVE_MCP_LOCAL_SDK_WORKSPACE_TOOL_NAMES.has(canonicalToolName)) return "localSdkWorkspace";
   return "pairedStudioSession";
 }
 function waveMcpToolRequiresStudioSession(toolName) {
@@ -42973,6 +42983,7 @@ function waveMcpToolFamily(toolName) {
   const contract = getWaveMcpToolContract(toolName);
   if (contract?.domain === "vfs") return "studio.vfs";
   if (contract?.domain === "asset") return "studio.assets";
+  if (contract?.domain === "modeling") return "wave.modeling";
   if (contract?.domain === "project") return "studio.project";
   if (contract?.domain === "preview") return "studio.preview";
   if (contract?.domain === "runtime") return "studio.preview";
@@ -43720,8 +43731,8 @@ function hasStringProperty(args, names) {
   return names.some((name) => typeof args[name] === "string");
 }
 function editWaveFileArgsAreExact(args) {
-  const path5 = trimString(args?.path, 240);
-  if (!path5) return false;
+  const path6 = trimString(args?.path, 240);
+  if (!path6) return false;
   const hasExactLineRange = isPositiveInteger(args?.startLine) && isPositiveInteger(args?.endLine) && hasStringProperty(args, ["text", "replacement"]);
   const hasExactTextReplace = typeof args?.oldText === "string" && args.oldText.length > 0 && hasStringProperty(args, ["newText", "replacement"]);
   return hasExactLineRange || hasExactTextReplace;
@@ -43755,7 +43766,7 @@ function waveMcpToolRoutingNote(toolName) {
     return " Direct Observe tool: call directly without start_wave_task. Pass taskRouteId only to attach this observation to an active Author/Diagnose route.";
   }
   if (contract.workMode === "operate") {
-    return " Direct Studio Operate tool: when the user asks for this exact Studio operation, call directly without start_wave_task. Pass taskRouteId only if this operation belongs to an active Author/Diagnose route.";
+    return " Direct Operate tool: when the user asks for this exact operation, call directly without start_wave_task. Pass taskRouteId only if this operation belongs to an active Author/Diagnose route.";
   }
   if (contract.workMode === "author" && contract.safety === "readOnly") {
     return " Direct Author lookup tool: callable without start_wave_task, but for normal code authoring use after intent chunks/Core Intent Pass and skill-family selection.";
@@ -44090,14 +44101,14 @@ function validateWaveMcpTaskToolCall(input) {
 function recordWaveMcpTaskEvidenceUse(input) {
   let evidence = input.evidence;
   const canonicalToolName = canonicalizeWaveMcpToolName(input.toolName);
-  const path5 = trimString(input.args?.path, 240);
+  const path6 = trimString(input.args?.path, 240);
   const skillId = trimString(input.args?.skillId, 120) || trimString(input.args?.id, 120);
   if (canonicalToolName === "list_wave_files") evidence = { ...evidence, filesListed: true };
   if (canonicalToolName === "read_wave_file") {
     evidence = {
       ...evidence,
       filesListed: true,
-      filesRead: uniqueStrings([...evidence.filesRead, path5].filter(Boolean), 64)
+      filesRead: uniqueStrings([...evidence.filesRead, path6].filter(Boolean), 64)
     };
   }
   if (canonicalToolName === "find_wave_assets_by_category") evidence = { ...evidence, assetsListed: true };
@@ -44794,8 +44805,8 @@ function optionalStringArray(value) {
   const strings = rawItems.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
   return strings.length > 0 ? strings : void 0;
 }
-function normalizeWaveFilePath(path5) {
-  const trimmed = path5.trim();
+function normalizeWaveFilePath(path6) {
+  const trimmed = path6.trim();
   if (!trimmed) return trimmed;
   return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
 }
@@ -44931,9 +44942,9 @@ function readPathArray(value) {
   return value.map((item) => {
     if (typeof item === "string") return item;
     const record = readRecord(item);
-    const path5 = record?.path;
-    return typeof path5 === "string" ? path5 : null;
-  }).filter((path5) => typeof path5 === "string" && path5.length > 0);
+    const path6 = record?.path;
+    return typeof path6 === "string" ? path6 : null;
+  }).filter((path6) => typeof path6 === "string" && path6.length > 0);
 }
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -45910,6 +45921,318 @@ async function runLocalSdkLookupTool(input) {
   );
 }
 
+// ../../scripts/wavegenie-sdk/modeling/modelingJob.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path2 from "node:path";
+function sanitizeAssetName(rawName) {
+  const sanitized = rawName.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "");
+  return sanitized || "generated_model";
+}
+function jsonValueOrNull(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value === "number" && Number.isNaN(value) ? null : value;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => jsonValueOrNull(item));
+    return items.every((item) => item !== null) ? items : null;
+  }
+  if (isRecord2(value)) {
+    const entries = Object.entries(value);
+    const result = {};
+    for (const [key, item] of entries) {
+      const normalized = jsonValueOrNull(item);
+      if (normalized === null) return null;
+      result[key] = normalized;
+    }
+    return result;
+  }
+  return null;
+}
+function normalizeKnownDimensionsMm(value) {
+  if (!isRecord2(value)) return null;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!key.trim()) continue;
+    const normalized = jsonValueOrNull(item);
+    if (normalized === null) return null;
+    result[key.trim()] = normalized;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function parseModelingJobArgs(args) {
+  const sourcePrompt = normalizeOptionalString(args?.sourcePrompt) ?? normalizeOptionalString(args?.prompt) ?? normalizeOptionalString(args?.description);
+  if (!sourcePrompt) {
+    return errorToolResult(
+      "invalid_arguments",
+      "`create_wave_3d_modeling_job` needs sourcePrompt, prompt, or description."
+    );
+  }
+  const rawAssetName = normalizeOptionalString(args?.assetName) ?? normalizeOptionalString(args?.name) ?? sourcePrompt.split(/\s+/u).slice(0, 5).join("_");
+  const knownDimensionsMm = typeof args?.knownDimensionsMm === "undefined" ? null : normalizeKnownDimensionsMm(args.knownDimensionsMm);
+  if (typeof args?.knownDimensionsMm !== "undefined" && !knownDimensionsMm) {
+    return errorToolResult(
+      "invalid_arguments",
+      "`knownDimensionsMm` must be a JSON object with only JSON-safe values."
+    );
+  }
+  return {
+    assetName: sanitizeAssetName(rawAssetName),
+    sourcePrompt,
+    screenshotPaths: optionalStringArray(args?.screenshotPaths) ?? [],
+    referenceImagePaths: optionalStringArray(args?.referenceImagePaths) ?? [],
+    targetStyle: normalizeOptionalString(args?.targetStyle) ?? null,
+    intendedUse: normalizeOptionalString(args?.intendedUse) ?? null,
+    requiredParts: optionalStringArray(args?.requiredParts) ?? [],
+    knownDimensionsMm
+  };
+}
+function markdownList(items, emptyText) {
+  if (items.length === 0) return `- ${emptyText}`;
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function buildModelingSupportFiles(input) {
+  const briefJson = JSON.stringify({
+    assetName: input.assetName,
+    sourcePrompt: input.sourcePrompt,
+    screenshotPaths: input.screenshotPaths,
+    referenceImagePaths: input.referenceImagePaths,
+    targetStyle: input.targetStyle,
+    intendedUse: input.intendedUse,
+    requiredParts: input.requiredParts,
+    knownDimensionsMm: input.knownDimensionsMm,
+    outputContract: {
+      preferredModelFile: `${input.assetName}.glb`,
+      optionalCadFile: `${input.assetName}.step`,
+      waveStudioImport: "Use create_wave_asset_upload/upload_wave_asset after GLB exists, then author code with models.<assetName>."
+    }
+  }, null, 2);
+  const parameterTemplate = JSON.stringify({
+    assetName: input.assetName,
+    units: "millimeter",
+    parameters: {
+      overall_width: input.knownDimensionsMm?.overall_width ?? 1e3,
+      overall_depth: input.knownDimensionsMm?.overall_depth ?? 600,
+      overall_height: input.knownDimensionsMm?.overall_height ?? 500,
+      bevel_radius: 12
+    },
+    parts: input.requiredParts.length > 0 ? input.requiredParts.map((partName) => ({ name: partName, materialHint: "default" })) : [{ name: "body", materialHint: "default" }]
+  }, null, 2);
+  return [
+    {
+      fileName: "README.md",
+      role: "workflow",
+      content: `# WaveEngine 3D Modeling Job: ${input.assetName}
+
+This folder is a local SDK modeling scaffold. It does not mean a GLB has been generated yet.
+
+## Source request
+
+${input.sourcePrompt}
+
+## Screenshot inputs
+
+${markdownList(input.screenshotPaths, "No screenshot paths provided. Use capture_wave_screenshot first when visual matching matters.")}
+
+## Reference image inputs
+
+${markdownList(input.referenceImagePaths, "No reference image paths provided.")}
+
+## Workflow
+
+1. Use \`cad-sheet-prompt.md\` to derive a CAD sheet or parameter spec from screenshots/reference images.
+2. Fill \`parameters.template.json\`.
+3. Run \`python build_step.py parameters.template.json out\` after installing CadQuery/OCP locally.
+4. Convert the STEP/mesh result to GLB with your approved modeling pipeline.
+5. Upload the GLB through Wave Studio MCP asset upload tools.
+6. Author scene code with \`models.${input.assetName}\`.
+
+## Safety
+
+Keep API keys and private screenshots out of commits. Generated assets must be reviewed before upload.
+`
+    },
+    {
+      fileName: "asset-brief.json",
+      role: "brief",
+      content: `${briefJson}
+`
+    },
+    {
+      fileName: "cad-sheet-prompt.md",
+      role: "prompt",
+      content: `Create a CAD-ready model specification for this WaveEngine asset.
+
+Asset name: ${input.assetName}
+Request: ${input.sourcePrompt}
+Target style: ${input.targetStyle ?? "match source/reference"}
+Intended use: ${input.intendedUse ?? "WaveEngine scene asset"}
+Required parts: ${input.requiredParts.length > 0 ? input.requiredParts.join(", ") : "infer minimal public-facing parts"}
+
+Use the screenshots/reference images as visual evidence. Return:
+
+- Orthographic front/side/top proportions.
+- Named visible parts.
+- Dimensions in millimeters.
+- Bevels, thickness, symmetry, repeating details.
+- Material/color hints only. Do not invent private engine internals.
+- A JSON parameter block compatible with parameters.template.json.
+`
+    },
+    {
+      fileName: "parameter-spec.schema.json",
+      role: "schema",
+      content: `${JSON.stringify({
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        title: "WaveEngine 3D Modeling Parameters",
+        type: "object",
+        required: ["assetName", "units", "parameters", "parts"],
+        additionalProperties: false,
+        properties: {
+          assetName: { type: "string", minLength: 1 },
+          units: { type: "string", enum: ["millimeter"] },
+          parameters: {
+            type: "object",
+            additionalProperties: { type: ["number", "string", "boolean"] }
+          },
+          parts: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "object",
+              required: ["name"],
+              additionalProperties: false,
+              properties: {
+                name: { type: "string", minLength: 1 },
+                materialHint: { type: "string" }
+              }
+            }
+          }
+        }
+      }, null, 2)}
+`
+    },
+    {
+      fileName: "parameters.template.json",
+      role: "parameters",
+      content: `${parameterTemplate}
+`
+    },
+    {
+      fileName: "build_step.py",
+      role: "python-cad-scaffold",
+      content: `#!/usr/bin/env python3
+"""WaveEngine local CAD scaffold.
+
+This is a starting point, not a magic model generator. Replace build_model()
+with the CAD recipe derived from cad-sheet-prompt.md.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import sys
+
+try:
+    import cadquery as cq
+except ImportError as exc:
+    raise SystemExit(
+        "CadQuery is required. Install it in your local modeling environment before running this scaffold."
+    ) from exc
+
+
+def read_params(path: pathlib.Path) -> dict:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def number_param(params: dict, name: str, fallback: float) -> float:
+    value = params.get("parameters", {}).get(name, fallback)
+    if isinstance(value, (int, float)):
+        return float(value)
+    return fallback
+
+
+def build_model(params: dict) -> cq.Workplane:
+    width = number_param(params, "overall_width", 1000)
+    depth = number_param(params, "overall_depth", 600)
+    height = number_param(params, "overall_height", 500)
+    bevel_radius = number_param(params, "bevel_radius", 12)
+    model = cq.Workplane("XY").box(width, depth, height)
+    if bevel_radius > 0:
+        model = model.edges().fillet(bevel_radius)
+    return model
+
+
+def main() -> None:
+    if len(sys.argv) != 3:
+        raise SystemExit("usage: python build_step.py parameters.template.json out")
+    params_path = pathlib.Path(sys.argv[1])
+    out_dir = pathlib.Path(sys.argv[2])
+    out_dir.mkdir(parents=True, exist_ok=True)
+    params = read_params(params_path)
+    asset_name = str(params.get("assetName") or "${input.assetName}")
+    step_path = out_dir / f"{asset_name}.step"
+    cq.exporters.export(build_model(params), str(step_path))
+    print(f"Wrote {step_path}")
+
+
+if __name__ == "__main__":
+    main()
+`
+    },
+    {
+      fileName: "validation-checklist.md",
+      role: "validation",
+      content: `# Validation checklist
+
+- Silhouette matches source screenshots from front/side/top.
+- Scale is correct for WaveEngine world use.
+- Parts are named for future objectModel/part authoring where useful.
+- Material slots are clean and simple.
+- GLB loads in Wave Studio before code authoring.
+- Uploaded asset appears as \`models.${input.assetName}\`.
+`
+    }
+  ];
+}
+async function createWave3dModelingJobTool(args) {
+  const parsed = parseModelingJobArgs(args);
+  if ("content" in parsed) return parsed;
+  const jobId = `wave_model_${parsed.assetName}_${randomUUID().slice(0, 8)}`;
+  const jobDir = path2.join(tmpdir(), "wave3d-agent-sdk", "modeling-jobs", jobId);
+  const supportFiles = buildModelingSupportFiles(parsed);
+  await mkdir(jobDir, { recursive: true });
+  await Promise.all(supportFiles.map((file) => writeFile(path2.join(jobDir, file.fileName), file.content, "utf8")));
+  return successToolResult({
+    ok: true,
+    tool: "create_wave_3d_modeling_job",
+    status: "scaffolded",
+    localSdk: true,
+    generatedAssetReady: false,
+    jobId,
+    jobDir,
+    assetName: parsed.assetName,
+    supportFiles: supportFiles.map((file) => ({
+      fileName: file.fileName,
+      role: file.role,
+      path: path2.join(jobDir, file.fileName)
+    })),
+    nextActions: [
+      "Use cad-sheet-prompt.md plus screenshots/reference images to produce a CAD parameter spec.",
+      "Fill parameters.template.json and run the Python scaffold only in a local modeling environment with CadQuery installed.",
+      "Convert generated model output to GLB, then upload with create_wave_asset_upload/upload_wave_asset.",
+      `After upload, author WaveEngine scene code with models.${parsed.assetName}.`
+    ],
+    caveats: [
+      "This tool creates a modeling job scaffold only; it does not call a cloud model generator.",
+      "Do not commit private screenshots, prompts, or generated assets without review."
+    ]
+  });
+}
+
 // ../../src/lib/waveStudio/aiAssist/bridge/assetListGuidance.ts
 function buildWaveAssetListGuidance(input) {
   const hasQuery = typeof input.query === "string" && input.query.trim().length > 0;
@@ -46401,7 +46724,7 @@ function reportHotReloadUnsafeUsage(params) {
     })
   });
 }
-function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOAD_UNSAFE_ERROR_LIMIT) {
+function collectRuntimeHotReloadSafetyDiagnostics(path6, code, limit = HOT_RELOAD_UNSAFE_ERROR_LIMIT) {
   const diagnostics = [];
   if (limit <= 0) return diagnostics;
   const reported = /* @__PURE__ */ new Set();
@@ -46446,34 +46769,34 @@ function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOA
     const receiverPath = previousChar === "." ? readPropertyReceiverPath(code, tokenStart) : "";
     const globalGuidance = HOT_RELOAD_UNSAFE_GLOBAL_CALLBACKS.get(token);
     if (globalGuidance) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: globalGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: globalGuidance, diagnostics, reported });
       continue;
     }
     const listenerGuidance = HOT_RELOAD_UNSAFE_LISTENER_CALLBACKS.get(token);
     if (listenerGuidance && isCall) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: listenerGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: listenerGuidance, diagnostics, reported });
       continue;
     }
     const promiseGuidance = HOT_RELOAD_UNSAFE_PROMISE_CALLBACKS.get(token);
     if (promiseGuidance && previousChar === "." && isCall) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: promiseGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: promiseGuidance, diagnostics, reported });
       continue;
     }
     const eventBusGuidance = HOT_RELOAD_UNSAFE_EVENTBUS_CALLBACKS.get(token);
     if (eventBusGuidance && previousChar === "." && isCall && isWaveEventBusReceiverPath(receiverPath)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: eventBusGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: eventBusGuidance, diagnostics, reported });
       continue;
     }
     const sceneEventGuidance = HOT_RELOAD_UNSAFE_SCENE_EVENT_CALLBACKS.get(token);
     if (sceneEventGuidance && previousChar === "." && isCall && isWaveSceneEventReceiverPath(receiverPath)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: sceneEventGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: sceneEventGuidance, diagnostics, reported });
       continue;
     }
     const forbiddenStudioSceneMethodGuidance = HOT_RELOAD_FORBIDDEN_STUDIO_SCENE_METHODS.get(token);
     if (forbiddenStudioSceneMethodGuidance && previousChar === "." && isCall && isWaveSceneEventReceiverPath(receiverPath)) {
       reportHotReloadUnsafeUsage({
         code,
-        path: path5,
+        path: path6,
         token,
         offset: tokenStart,
         severity: "error",
@@ -46485,12 +46808,12 @@ function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOA
     }
     const constructorGuidance = HOT_RELOAD_UNSAFE_CONSTRUCTORS.get(token);
     if (constructorGuidance && (previousIdentifier === "new" || previousChar === "." && isCall)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: constructorGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: constructorGuidance, diagnostics, reported });
       continue;
     }
     const eventHandlerGuidance = HOT_RELOAD_UNSAFE_EVENT_HANDLER_ASSIGNMENTS.get(token);
     if (eventHandlerGuidance && previousChar === "." && nextNonWhitespace === "=") {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: eventHandlerGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: eventHandlerGuidance, diagnostics, reported });
     }
   }
   return diagnostics;
@@ -46883,16 +47206,16 @@ function parseMutationOperations(value) {
   }
   return operations;
 }
-function isAuthoredCodePath(path5) {
-  const normalized = path5.trim().toLowerCase();
+function isAuthoredCodePath(path6) {
+  const normalized = path6.trim().toLowerCase();
   return normalized.endsWith(".ts") || normalized.endsWith(".js");
 }
-function warnUnsafeCallbackUsage(path5, code) {
-  if (!isAuthoredCodePath(path5) || !code.trim()) return;
-  const diagnostics = collectRuntimeHotReloadSafetyDiagnostics(path5, code);
+function warnUnsafeCallbackUsage(path6, code) {
+  if (!isAuthoredCodePath(path6) || !code.trim()) return;
+  const diagnostics = collectRuntimeHotReloadSafetyDiagnostics(path6, code);
   if (diagnostics.length === 0) return;
   console.warn([
-    `[WaveStudio][HotReloadSafety] Strong warning for ${path5}: code edits introduced unmanaged callback roots. The write is allowed, but preview will show a memory leak warning.`,
+    `[WaveStudio][HotReloadSafety] Strong warning for ${path6}: code edits introduced unmanaged callback roots. The write is allowed, but preview will show a memory leak warning.`,
     "Use Wave-owned callbacks, animation DSL, entity lifecycle/tick/state APIs, or Director/input APIs instead.",
     ...diagnostics.map((diagnostic) => diagnostic.message)
   ].join("\n"));
@@ -47055,8 +47378,8 @@ async function handleVfsTool(input) {
       return errorToolResult("session_not_found", LOCAL_SESSION_NOT_FOUND_MESSAGE);
     }
     const pathInput = typeof args?.path === "string" ? args.path : typeof args?.filePath === "string" ? args.filePath : "";
-    const path5 = normalizeWaveFilePath(pathInput);
-    if (!path5) {
+    const path6 = normalizeWaveFilePath(pathInput);
+    if (!path6) {
       return errorToolResult("invalid_arguments", "`read_wave_file` requires a non-empty string `path` (alias: `filePath`).");
     }
     const startLine = normalizeOptionalPositiveInteger(args?.startLine);
@@ -47075,7 +47398,7 @@ async function handleVfsTool(input) {
     try {
       const result = await context.commandBroker.enqueue(session.sessionId, {
         type: "readFile",
-        path: path5,
+        path: path6,
         ...ifMatchHash ? { ifMatchHash } : {},
         ...typeof effectiveStartLine === "number" ? { startLine: effectiveStartLine } : {},
         ...typeof endLine === "number" ? { endLine } : {}
@@ -47097,7 +47420,7 @@ async function handleVfsTool(input) {
         ...result.payload.range ? { editHint: "This was a scoped line read. For edits in this slice, prefer edit_wave_file with the same full-file line numbers. baseHash is optional for simple edits." } : {}
       });
     } catch (error) {
-      return errorToolResult("command_timeout", error instanceof Error ? error.message : "WaveEngine Agent SDK file read timed out.", { path: path5 });
+      return errorToolResult("command_timeout", error instanceof Error ? error.message : "WaveEngine Agent SDK file read timed out.", { path: path6 });
     }
   }
   if (name === "edit_wave_file") {
@@ -47109,21 +47432,21 @@ async function handleVfsTool(input) {
     ]);
     if ("result" in contentResult) return contentResult.result;
     if (typeof args?.blockContaining !== "undefined" || typeof args?.replaceBlockContaining !== "undefined" || typeof args?.deleteStatementContaining !== "undefined" || typeof args?.replaceBetween !== "undefined") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       const deleteNeedle = normalizeOptionalString(args?.deleteStatementContaining);
       const replacementResult = deleteNeedle ? { value: "" } : resolveReplacementAlias("text", args?.text, args?.replacement);
       if ("result" in replacementResult) return replacementResult.result;
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "Block edit requires `text`/`replacement`, or `deleteStatementContaining` for deletion.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47145,7 +47468,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "lineEdits",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           edits: [{
             startLine: range.startLine,
@@ -47159,7 +47482,7 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: deleteNeedle ? "deleteStatementContaining" : "replaceBlockContaining",
         editTarget: {
-          path: path5,
+          path: path6,
           startLine: range.startLine,
           endLine: range.endLine,
           targetReason: range.reason,
@@ -47172,28 +47495,28 @@ async function handleVfsTool(input) {
     const editArray = parseEditWaveFileEditsArray(args?.edits);
     if (editArray) {
       if ("result" in editArray) return editArray.result;
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       for (const edit of editArray.edits) {
-        warnUnsafeCallbackUsage(path5, edit.text);
+        warnUnsafeCallbackUsage(path6, edit.text);
       }
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
       const operations = editArray.type === "lineEdits" ? [{
         type: "lineEdits",
-        path: path5,
+        path: path6,
         baseHash: resolvedHash.baseHash,
         edits: editArray.edits
       }] : [{
         type: "textEdits",
-        path: path5,
+        path: path6,
         baseHash: resolvedHash.baseHash,
         edits: editArray.edits
       }];
@@ -47207,17 +47530,17 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: editArray.type === "lineEdits" ? "multiLineEdits" : "multiTextEdits",
         editTarget: {
-          path: path5,
+          path: path6,
           editCount: editArray.edits.length
         }
       });
     }
     const inferredMode = normalizeEditWaveFileMode(args?.mode) ?? (requireNonEmptyString(args?.oldText) ? "replaceText" : typeof args?.startLine !== "undefined" || typeof args?.endLine !== "undefined" ? "replaceLines" : typeof contentResult.value === "string" ? "replaceWholeFile" : "");
     if (inferredMode === "replaceLines") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
       const startLine = normalizeOptionalPositiveInteger(args?.startLine);
       const endLine = normalizeOptionalPositiveInteger(args?.endLine);
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       if (startLine === null || typeof startLine === "undefined") {
         return errorToolResult("invalid_arguments", "`startLine` must be a positive integer.");
       }
@@ -47232,13 +47555,13 @@ async function handleVfsTool(input) {
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "`text` or `replacement` must be a string. Use an empty string to delete the line range.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47262,7 +47585,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "lineEdits",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           edits: [{
             startLine,
@@ -47276,7 +47599,7 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: "replaceLines",
         editTarget: {
-          path: path5,
+          path: path6,
           startLine,
           endLine: finalEndLine,
           requestedEndLine,
@@ -47289,18 +47612,18 @@ async function handleVfsTool(input) {
       });
     }
     if (inferredMode === "replaceText") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
       const oldText = requireNonEmptyString(args?.oldText);
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       if (!oldText) {
         if (typeof contentResult.value === "string") {
-          warnUnsafeCallbackUsage(path5, contentResult.value);
+          warnUnsafeCallbackUsage(path6, contentResult.value);
           const sessionResult2 = resolveWritableSession(args, context);
           if ("result" in sessionResult2) return sessionResult2.result;
           const resolvedHash2 = await resolveEditBaseHash({
             context,
             session: sessionResult2.session,
-            path: path5,
+            path: path6,
             baseHash: args?.baseHash
           });
           if ("result" in resolvedHash2) return resolvedHash2.result;
@@ -47309,7 +47632,7 @@ async function handleVfsTool(input) {
             session: sessionResult2.session,
             operations: [{
               type: "writeFile",
-              path: path5,
+              path: path6,
               baseHash: resolvedHash2.baseHash,
               content: contentResult.value
             }],
@@ -47325,7 +47648,7 @@ async function handleVfsTool(input) {
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "`newText` or `replacement` must be a string. Use an empty string to delete the matched text.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const hasOccurrenceIndex = typeof args?.occurrenceIndex !== "undefined";
@@ -47338,7 +47661,7 @@ async function handleVfsTool(input) {
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47347,7 +47670,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "searchReplace",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           oldText,
           newText: replacementResult.value,
@@ -47360,15 +47683,15 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash);
     }
     if (inferredMode === "replaceWholeFile" && typeof contentResult.value === "string") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
-      warnUnsafeCallbackUsage(path5, contentResult.value);
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      warnUnsafeCallbackUsage(path6, contentResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47377,7 +47700,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "writeFile",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           content: contentResult.value
         }],
@@ -47389,12 +47712,12 @@ async function handleVfsTool(input) {
     return errorToolResult("invalid_arguments", "`edit_wave_file` could not infer the edit shape. Use oldText+newText, startLine+endLine+text, or path+text/content for whole-file replacement.");
   }
   if (name === "create_wave_file") {
-    const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-    if (!path5) return errorToolResult("invalid_arguments", "`create_wave_file` requires a non-empty string `path`.");
+    const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+    if (!path6) return errorToolResult("invalid_arguments", "`create_wave_file` requires a non-empty string `path`.");
     if (typeof args?.content !== "string") {
       return errorToolResult("invalid_arguments", "`content` must be a string.");
     }
-    warnUnsafeCallbackUsage(path5, args.content);
+    warnUnsafeCallbackUsage(path6, args.content);
     const overwrite = args?.overwrite === true || args?.forceOverwrite === true || args?.replaceExisting === true;
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
@@ -47403,7 +47726,7 @@ async function handleVfsTool(input) {
       session: sessionResult.session,
       operations: [{
         type: "createFile",
-        path: path5,
+        path: path6,
         content: args.content,
         runnable: typeof args?.runnable === "boolean" ? args.runnable : true,
         ...overwrite ? { overwrite: true } : {}
@@ -47434,14 +47757,14 @@ async function handleVfsTool(input) {
   if (name === "delete_wave_file") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-    if (!path5) return errorToolResult("invalid_arguments", "`delete_wave_file` requires a non-empty string `path`.");
+    const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+    if (!path6) return errorToolResult("invalid_arguments", "`delete_wave_file` requires a non-empty string `path`.");
     return await applyMutationOperations({
       context,
       session: sessionResult.session,
       operations: [{
         type: "deleteFile",
-        path: path5
+        path: path6
       }],
       ...runtimeVerificationArgs(args)
     });
@@ -49497,7 +49820,11 @@ var LOCAL_TOOL_DEFINITION_OVERRIDE_NAMES = /* @__PURE__ */ new Set([
 var LOCAL_EXTRA_TOOL_DEFINITION_NAMES = /* @__PURE__ */ new Set([
   "self_check_wave_mcp",
   "list_wave_sessions",
-  "get_active_wave_session"
+  "get_active_wave_session",
+  "create_wave_3d_modeling_job"
+]);
+var LOCAL_SDK_MODELING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_wave_3d_modeling_job"
 ]);
 var LOCAL_OPTIONAL_SESSION_TOOL_NAMES = /* @__PURE__ */ new Set([
   "get_wave_session",
@@ -49566,6 +49893,7 @@ var LOCAL_SDK_CONTROL_TOOL_NAMES = /* @__PURE__ */ new Set([
 var LOCAL_SDK_IMPLEMENTED_CANONICAL_TOOL_NAMES = /* @__PURE__ */ new Set([
   ...LOCAL_SDK_CONTROL_TOOL_NAMES,
   ...LOCAL_SDK_LOOKUP_TOOL_NAMES,
+  ...LOCAL_SDK_MODELING_TOOL_NAMES,
   ...[...LOCAL_OPTIONAL_SESSION_TOOL_NAMES].map((name) => canonicalizeWaveMcpToolName(name))
 ]);
 function isLocalMcpToolImplemented(name) {
@@ -49688,6 +50016,60 @@ function getReadToolDefinitions() {
         additionalProperties: false
       }
     },
+    {
+      name: "create_wave_3d_modeling_job",
+      description: "[wave.modeling] Create a local SDK 3D-modeling job scaffold from a prompt and optional screenshots/reference image paths. Writes README, CAD prompt, JSON parameter template/schema, Python CadQuery STEP scaffold, and validation checklist into a temp job folder. Does not generate/upload a GLB by itself; use asset upload tools after a real model file exists. Aliases: generate_wave_3d_model, create_wave_3d_model, create_wave_3d_model_from_screenshots.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sourcePrompt: {
+            type: "string",
+            description: 'Required modeling goal, e.g. "make a low-poly sea lion matching the screenshot". Aliases accepted by handler: prompt, description.'
+          },
+          prompt: {
+            type: "string",
+            description: "Alias for sourcePrompt."
+          },
+          description: {
+            type: "string",
+            description: "Alias for sourcePrompt."
+          },
+          assetName: {
+            type: "string",
+            description: "Optional public Wave asset/model name stem. Handler sanitizes to lowercase snake_case."
+          },
+          screenshotPaths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional local screenshot paths, usually returned from capture_wave_screenshot or supplied by user."
+          },
+          referenceImagePaths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional local reference image paths."
+          },
+          targetStyle: {
+            type: "string",
+            description: "Optional visual style constraint."
+          },
+          intendedUse: {
+            type: "string",
+            description: "Optional Wave scene usage target such as prop, actor, background, UI model, collision mesh."
+          },
+          requiredParts: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional named visible parts the generated model should preserve."
+          },
+          knownDimensionsMm: {
+            type: "object",
+            description: 'Optional JSON-safe dimension hints in millimeters, e.g. {"overall_width": 1200, "overall_height": 500}.',
+            additionalProperties: true
+          }
+        },
+        additionalProperties: false
+      }
+    },
     {
       name: "get_wave_session",
       description: "Return the Wave Studio browser session paired through the WaveEngine Agent SDK. Full Studio tools are available when this local endpoint is called with the adopted HTTP Gateway token from Wave Studio.",
@@ -49792,6 +50174,7 @@ function getLocalToolImplementationSummary() {
     implementedCanonicalToolCount: implementedCanonicalToolNames.length,
     localExtraToolNames: [...LOCAL_EXTRA_TOOL_DEFINITION_NAMES].sort(),
     localLookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort(),
+    localModelingToolNames: [...LOCAL_SDK_MODELING_TOOL_NAMES].sort(),
     omittedCanonicalToolNames: canonicalToolNames.filter((name) => !isLocalMcpToolImplemented(name))
   };
 }
@@ -49815,7 +50198,8 @@ function localSdkLookupStatus(waveEngineSdkCache) {
     corpusCacheReady,
     apiAndSkillQueryAvailable: corpusCacheReady,
     cacheMissAffectsLiveStudioTransport: false,
-    lookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort()
+    lookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort(),
+    localModelingToolNames: [...LOCAL_SDK_MODELING_TOOL_NAMES].sort()
   };
 }
 function jsonRpcToolIdempotencyKey(toolName, requestId) {
@@ -50280,10 +50664,10 @@ function screenshotBasePayload(payload, suggestedFilename) {
   };
 }
 async function saveScreenshotPayloadToLocalFile(payload, suggestedFilename) {
-  const directory = path2.join(tmpdir(), "wave3d-agent-sdk", "screenshots");
-  await mkdir(directory, { recursive: true });
-  const localPath = path2.join(directory, suggestedFilename);
-  await writeFile(localPath, Buffer.from(payload.dataBase64, "base64"));
+  const directory = path3.join(tmpdir2(), "wave3d-agent-sdk", "screenshots");
+  await mkdir2(directory, { recursive: true });
+  const localPath = path3.join(directory, suggestedFilename);
+  await writeFile2(localPath, Buffer.from(payload.dataBase64, "base64"));
   return localPath;
 }
 function normalizeRuntimeMarkerSource(value) {
@@ -50476,7 +50860,7 @@ async function callReadTool(name, args, context) {
   if (name === "start_wave_task") {
     const routeResult = startWaveMcpTaskRoute({
       args,
-      taskRouteId: `wgtask_${randomUUID()}`,
+      taskRouteId: `wgtask_${randomUUID2()}`,
       now: nowIso(),
       seedEvidence: mergeWaveMcpTaskEvidence(
         getLocalPreTaskEvidence(context) ?? createWaveMcpEmptyTaskEvidence(),
@@ -50665,7 +51049,8 @@ async function callReadTool(name, args, context) {
         "studio.project: list_wave_project_templates, new_wave_project, list_wave_projects, read_wave_project, rename_wave_project, open_wave_project, save_wave_project, share_wave_project",
         "studio.preview: hot_reload_wave_preview (alias: hotreload_wave_preview), run_wave_preview (alias: run_project), pause_wave_preview (alias: pause_wave_engine), resume_wave_preview (alias: resume_wave_engine), get_wave_runtime_diagnostics (alias: get_wave_errors), get_wave_runtime_performance_snapshot (alias: get_wave_runtime_performance)",
         "studio.capture: capture_wave_screenshot (alias: get_wave_screenshot), get_wave_runtime_entity_snapshot (alias: get_wave_entity_snapshot), list_wave_runtime_markers (alias: list_wave_markers)",
-        "wave.authoring: list_wave_skill_families, query_wave_skills, get_wave_skill, query_wave_api"
+        "wave.authoring: list_wave_skill_families, query_wave_skills, get_wave_skill, query_wave_api",
+        "wave.modeling: create_wave_3d_modeling_job (aliases: generate_wave_3d_model, create_wave_3d_model, create_wave_3d_model_from_screenshots) creates local SDK support files; upload generated GLB later with asset tools"
       ],
       rules: [
         "studio.* labels are categories, not callable tools.",
@@ -50686,6 +51071,9 @@ async function callReadTool(name, args, context) {
       args
     });
   }
+  if (name === "create_wave_3d_modeling_job") {
+    return await createWave3dModelingJobTool(args);
+  }
   if (name === "get_wave_command_result") {
     const requestId = requireNonEmptyString(args?.requestId);
     if (!requestId) {
@@ -50938,15 +51326,15 @@ async function callReadTool(name, args, context) {
   if (name === "rename_wave_asset") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = requireNonEmptyString(args?.path);
+    const path6 = requireNonEmptyString(args?.path);
     const nextName = requireNonEmptyString(stringAliasArg(args, ["name", "newName", "displayName"]));
-    if (!path5 || !nextName) return errorToolResult("invalid_arguments", "`rename_wave_asset` requires non-empty `path` and `name`.");
+    if (!path6 || !nextName) return errorToolResult("invalid_arguments", "`rename_wave_asset` requires non-empty `path` and `name`.");
     return await enqueueBrowserCommand({
       context,
       session: sessionResult.session,
       command: {
         type: "renameAsset",
-        path: path5,
+        path: path6,
         name: nextName
       }
     });
@@ -50954,14 +51342,14 @@ async function callReadTool(name, args, context) {
   if (name === "delete_wave_asset") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = requireNonEmptyString(args?.path);
-    if (!path5) return errorToolResult("invalid_arguments", "`delete_wave_asset` requires a non-empty `path`.");
+    const path6 = requireNonEmptyString(args?.path);
+    if (!path6) return errorToolResult("invalid_arguments", "`delete_wave_asset` requires a non-empty `path`.");
     return await enqueueBrowserCommand({
       context,
       session: sessionResult.session,
       command: {
         type: "deleteAsset",
-        path: path5
+        path: path6
       }
     });
   }
@@ -51415,9 +51803,9 @@ async function handleWaveGenieMcpRequest(request, context) {
 }
 
 // ../../scripts/wavegenie-sdk/sessionRegistry.ts
-import { createHash as createHash4, randomUUID as randomUUID2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function createSessionId() {
-  return `wgb_${randomUUID2()}`;
+  return `wgb_${randomUUID3()}`;
 }
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -51557,18 +51945,18 @@ var WaveGenieBridgeSessionRegistry = class {
 };
 
 // ../../scripts/wavegenie-sdk/assetStaging.ts
-import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import { mkdir as mkdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import path3 from "node:path";
+import { mkdir as mkdir3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import path4 from "node:path";
 var MAX_LOCAL_ASSET_UPLOAD_BYTES = 300 * 1024 * 1024;
 var MAX_LOCAL_ASSET_UPLOAD_CHUNKS = 256;
-var STAGING_ROOT = path3.join(tmpdir2(), "wave3d-agent-sdk-asset-staging");
+var STAGING_ROOT = path4.join(tmpdir3(), "wave3d-agent-sdk-asset-staging");
 var LOCAL_DIRECT_UPLOAD_TTL_MS = 60 * 60 * 1e3;
 var DEFAULT_LOCAL_ASSET_UPLOAD_TTL_MS = 24 * 60 * 60 * 1e3;
 function createUploadId() {
-  return `wgbupload_${randomUUID3()}`;
+  return `wgbupload_${randomUUID4()}`;
 }
 function createSecret() {
   return randomBytes2(24).toString("base64url");
@@ -51628,8 +52016,8 @@ var LocalAssetUploadStagingStore = class {
     this.uploads = /* @__PURE__ */ new Map();
   }
   async ensureUploadDir(uploadId) {
-    const uploadDir = path3.join(STAGING_ROOT, hashPathPart(uploadId));
-    await mkdir2(uploadDir, { recursive: true });
+    const uploadDir = path4.join(STAGING_ROOT, hashPathPart(uploadId));
+    await mkdir3(uploadDir, { recursive: true });
     return uploadDir;
   }
   createPartUrl(uploadId, chunkIndex, readToken) {
@@ -51668,8 +52056,8 @@ var LocalAssetUploadStagingStore = class {
     const currentBytes = [...upload.parts.values()].filter((part2) => part2.chunkIndex !== chunkIndex).reduce((total, part2) => total + part2.sizeBytes, 0);
     assertUploadSize(currentBytes + bytes.byteLength);
     const uploadDir = await this.ensureUploadDir(upload.uploadId);
-    const filePath = path3.join(uploadDir, `part-${chunkIndex}.bin`);
-    await writeFile2(filePath, bytes);
+    const filePath = path4.join(uploadDir, `part-${chunkIndex}.bin`);
+    await writeFile3(filePath, bytes);
     const part = {
       chunkIndex,
       sizeBytes: bytes.byteLength,
@@ -51682,7 +52070,7 @@ var LocalAssetUploadStagingStore = class {
   async putStreamPart(input) {
     const currentBytes = [...input.upload.parts.values()].filter((part2) => part2.chunkIndex !== input.chunkIndex).reduce((total, part2) => total + part2.sizeBytes, 0);
     const uploadDir = await this.ensureUploadDir(input.upload.uploadId);
-    const filePath = path3.join(uploadDir, `part-${input.chunkIndex}.bin`);
+    const filePath = path4.join(uploadDir, `part-${input.chunkIndex}.bin`);
     const output = createWriteStream(filePath, { flags: "w" });
     let writtenBytes = 0;
     try {
@@ -51836,7 +52224,7 @@ var LocalAssetUploadStagingStore = class {
     const upload = this.uploads.get(uploadId);
     if (!upload) return 0;
     this.uploads.delete(uploadId);
-    const uploadDir = path3.join(STAGING_ROOT, hashPathPart(uploadId));
+    const uploadDir = path4.join(STAGING_ROOT, hashPathPart(uploadId));
     await rm(uploadDir, { recursive: true, force: true });
     return upload.parts.size;
   }
@@ -51861,7 +52249,7 @@ var MAX_DIRECT_UPLOAD_BODY_BYTES = 300 * 1024 * 1024;
 var LOCAL_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/i;
 var TRUSTED_WAVE_STUDIO_ORIGIN_RE = /^https:\/\/(www\.)?wave3d\.ai$/i;
 function createBridgeId() {
-  return `wgbridge_${randomUUID4()}`;
+  return `wgbridge_${randomUUID5()}`;
 }
 function isAllowedStudioOrigin(origin) {
   if (!origin) return true;
@@ -52364,10 +52752,10 @@ function readBooleanFlag(options, name) {
   return options.flags.get(name) === true;
 }
 function getDefaultCacheRoot() {
-  return path4.join(homedir2(), ".wave3d", "agent-cache");
+  return path5.join(homedir2(), ".wave3d", "agent-cache");
 }
 function getCacheRoot(options) {
-  return path4.resolve(readStringFlag(options, "cache-dir") ?? process.env[CACHE_DIR_ENV] ?? getDefaultCacheRoot());
+  return path5.resolve(readStringFlag(options, "cache-dir") ?? process.env[CACHE_DIR_ENV] ?? getDefaultCacheRoot());
 }
 function getDefaultMcpUrl(options) {
   const port = readNumberFlag(options, "port") ?? DEFAULT_PORT2;
@@ -52386,29 +52774,29 @@ function assertSafeListenHost(host, allowNetwork) {
   throw new Error(`Refusing to listen on non-loopback host ${host}. Use --allow-network only on a trusted network.`);
 }
 function assertSafeCacheRoot(cacheRoot) {
-  const resolved = path4.resolve(cacheRoot);
-  const root = path4.parse(resolved).root;
+  const resolved = path5.resolve(cacheRoot);
+  const root = path5.parse(resolved).root;
   const dangerous = /* @__PURE__ */ new Set([
     root,
-    path4.resolve(homedir2()),
-    path4.resolve(process.cwd()),
-    path4.resolve(path4.dirname(homedir2()))
+    path5.resolve(homedir2()),
+    path5.resolve(process.cwd()),
+    path5.resolve(path5.dirname(homedir2()))
   ]);
   if (dangerous.has(resolved)) {
     throw new Error(`Refusing to use dangerous cache directory: ${resolved}`);
   }
-  const depth = path4.relative(root, resolved).split(path4.sep).filter(Boolean).length;
+  const depth = path5.relative(root, resolved).split(path5.sep).filter(Boolean).length;
   if (depth < 2) {
     throw new Error(`Refusing to use shallow cache directory: ${resolved}`);
   }
 }
 function isDefaultCacheRoot(cacheRoot) {
-  return path4.resolve(cacheRoot) === path4.resolve(getDefaultCacheRoot());
+  return path5.resolve(cacheRoot) === path5.resolve(getDefaultCacheRoot());
 }
 async function markCacheRoot(cacheRoot) {
   assertSafeCacheRoot(cacheRoot);
-  await mkdir3(cacheRoot, { recursive: true });
-  await writeFile3(path4.join(cacheRoot, CACHE_MARKER_FILE), "wave3d-agent-cache\n");
+  await mkdir4(cacheRoot, { recursive: true });
+  await writeFile4(path5.join(cacheRoot, CACHE_MARKER_FILE), "wave3d-agent-cache\n");
 }
 function isSafePathSegment(value) {
   return /^[A-Za-z0-9._-]+$/.test(value);
@@ -52737,11 +53125,11 @@ function assertCorpusManifestMatches(actual, expected) {
   }
 }
 function getBundledSdkDirectory() {
-  return path4.join(path4.dirname(fileURLToPath(import.meta.url)), BUNDLED_SDK_DIR_NAME);
+  return path5.join(path5.dirname(fileURLToPath(import.meta.url)), BUNDLED_SDK_DIR_NAME);
 }
 async function readBundledSdkManifest() {
   try {
-    const parsed = JSON.parse(await readFile2(path4.join(getBundledSdkDirectory(), "manifest.json"), "utf8"));
+    const parsed = JSON.parse(await readFile2(path5.join(getBundledSdkDirectory(), "manifest.json"), "utf8"));
     return isCorpusManifest(parsed) ? parsed : null;
   } catch {
     return null;
@@ -52749,7 +53137,7 @@ async function readBundledSdkManifest() {
 }
 async function readBundledSdkZip(manifest) {
   const bundleFileName = requireSafePathSegment(manifest.bundleFileName, "Bundled SDK zip file name");
-  const bytes = await readFile2(path4.join(getBundledSdkDirectory(), bundleFileName));
+  const bytes = await readFile2(path5.join(getBundledSdkDirectory(), bundleFileName));
   if (bytes.length > MAX_CORPUS_ZIP_BYTES2) {
     throw new Error(`Bundled SDK zip is too large: ${bytes.length} bytes.`);
   }
@@ -52760,11 +53148,11 @@ async function writeCorpusCacheFromZip(input) {
   await markCacheRoot(cacheRoot);
   const cacheKey = requireSafePathSegment(input.manifest.cacheKey, "Corpus cacheKey");
   const bundleFileName = requireSafePathSegment(input.manifest.bundleFileName, "Corpus bundle file name");
-  const versionDir = path4.join(cacheRoot, cacheKey);
-  const corpusDir = path4.join(versionDir, "corpus");
-  await mkdir3(versionDir, { recursive: true });
-  await writeFile3(path4.join(versionDir, "corpus-handshake.json"), JSON.stringify(input.handshake, null, 2));
-  await writeFile3(path4.join(versionDir, bundleFileName), input.zipBytes);
+  const versionDir = path5.join(cacheRoot, cacheKey);
+  const corpusDir = path5.join(versionDir, "corpus");
+  await mkdir4(versionDir, { recursive: true });
+  await writeFile4(path5.join(versionDir, "corpus-handshake.json"), JSON.stringify(input.handshake, null, 2));
+  await writeFile4(path5.join(versionDir, bundleFileName), input.zipBytes);
   await extractZipToDirectory(input.zipBytes, corpusDir, input.manifest);
   await buildSearchIndex(corpusDir);
   const current = {
@@ -52776,7 +53164,7 @@ async function writeCorpusCacheFromZip(input) {
     sourceVersions: input.manifest.sourceVersions,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile3(path4.join(cacheRoot, "current.json"), JSON.stringify(current, null, 2));
+  await writeFile4(path5.join(cacheRoot, "current.json"), JSON.stringify(current, null, 2));
   return current;
 }
 async function ensureBundledSdkCache(options, input) {
@@ -52915,16 +53303,16 @@ async function commandDoctor(options) {
   await commandCacheStatus(options);
 }
 function normalizeZipEntryPath(entryName) {
-  const normalized = path4.posix.normalize(entryName.replace(/\\/g, "/"));
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("\0") || path4.posix.isAbsolute(normalized)) {
+  const normalized = path5.posix.normalize(entryName.replace(/\\/g, "/"));
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("\0") || path5.posix.isAbsolute(normalized)) {
     throw new Error(`Unsafe corpus zip entry: ${entryName}`);
   }
   return normalized;
 }
 function resolveZipOutputPath(targetDir, normalizedEntryName) {
-  const outputPath = path4.resolve(targetDir, ...normalizedEntryName.split("/"));
-  const relative = path4.relative(targetDir, outputPath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+  const outputPath = path5.resolve(targetDir, ...normalizedEntryName.split("/"));
+  const relative = path5.relative(targetDir, outputPath);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
     throw new Error(`Unsafe corpus zip output path: ${normalizedEntryName}`);
   }
   return outputPath;
@@ -52938,8 +53326,8 @@ function isCorpusCurrentRecord(value) {
   return isRecord4(value) && typeof value.cacheKey === "string" && typeof value.version === "string" && (typeof value.formatVersion === "undefined" || typeof value.formatVersion === "string") && typeof value.bundleHash === "string" && typeof value.corpusDir === "string" && (typeof value.sourceVersions === "undefined" || isRecord4(value.sourceVersions)) && (typeof value.updatedAt === "undefined" || typeof value.updatedAt === "string");
 }
 function isPathInsideDirectory2(parentDir, childPath) {
-  const relative = path4.relative(path4.resolve(parentDir), path4.resolve(childPath));
-  return relative === "" || !!relative && !relative.startsWith("..") && !path4.isAbsolute(relative);
+  const relative = path5.relative(path5.resolve(parentDir), path5.resolve(childPath));
+  return relative === "" || !!relative && !relative.startsWith("..") && !path5.isAbsolute(relative);
 }
 async function readCorpusManifestFromDirectory(corpusDir) {
   try {
@@ -52984,7 +53372,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
   const allowedPaths = /* @__PURE__ */ new Set(["manifest.json", ...expectedFiles.keys()]);
   const extractedFilePaths = /* @__PURE__ */ new Set();
   await rm2(targetDir, { recursive: true, force: true });
-  await mkdir3(targetDir, { recursive: true });
+  await mkdir4(targetDir, { recursive: true });
   const entries = Object.values(zip.files);
   if (entries.length > MAX_CORPUS_FILE_COUNT) {
     throw new Error(`Corpus zip has too many entries: ${entries.length}.`);
@@ -53001,7 +53389,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
       throw new Error(`Corpus extracted size is too large: ${extractedBytes + expectedSize} bytes.`);
     }
     const outputPath = resolveZipOutputPath(targetDir, normalized);
-    await mkdir3(path4.dirname(outputPath), { recursive: true });
+    await mkdir4(path5.dirname(outputPath), { recursive: true });
     const content = await entry.async("nodebuffer");
     extractedBytes += content.length;
     if (extractedBytes > MAX_CORPUS_EXTRACTED_BYTES2) {
@@ -53019,7 +53407,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
       }
       extractedFilePaths.add(normalized);
     }
-    await writeFile3(outputPath, content);
+    await writeFile4(outputPath, content);
   }
   for (const expectedPath of expectedFiles.keys()) {
     if (!extractedFilePaths.has(expectedPath)) {
@@ -53031,7 +53419,7 @@ function parseJsonLines2(content) {
   return content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
 }
 async function buildSearchIndex(corpusDir) {
-  const searchPath = path4.join(corpusDir, "search", "search-documents.jsonl");
+  const searchPath = path5.join(corpusDir, "search", "search-documents.jsonl");
   const content = await readFile2(searchPath, "utf8");
   const documents = parseJsonLines2(content);
   const uniqueDocuments = [];
@@ -53058,7 +53446,7 @@ async function buildSearchIndex(corpusDir) {
     }
   });
   miniSearch.addAll(uniqueDocuments);
-  await writeFile3(path4.join(corpusDir, "search", "minisearch-index.json"), JSON.stringify(miniSearch.toJSON()));
+  await writeFile4(path5.join(corpusDir, "search", "minisearch-index.json"), JSON.stringify(miniSearch.toJSON()));
 }
 async function commandCacheRefresh(options) {
   const mcpUrl = readStringFlag(options, "mcp-url");
@@ -53076,12 +53464,12 @@ async function commandCacheRefresh(options) {
   console.log(`Cache root: ${getCacheRoot(options)}`);
 }
 async function readCurrentCache(cacheRoot) {
-  const currentPath = path4.join(cacheRoot, "current.json");
+  const currentPath = path5.join(cacheRoot, "current.json");
   if (!existsSync2(currentPath)) return null;
   try {
     const parsed = JSON.parse(await readFile2(currentPath, "utf8"));
     if (!isCorpusCurrentRecord(parsed)) return null;
-    const corpusDir = path4.resolve(parsed.corpusDir);
+    const corpusDir = path5.resolve(parsed.corpusDir);
     if (!isPathInsideDirectory2(cacheRoot, corpusDir)) return null;
     const manifest = await readCorpusManifestFromDirectory(corpusDir);
     if (!manifest || !corpusCurrentMatchesManifest(parsed, manifest)) return null;
@@ -53110,7 +53498,7 @@ async function commandCacheStatus(options) {
 async function commandCacheClear(options) {
   const cacheRoot = getCacheRoot(options);
   assertSafeCacheRoot(cacheRoot);
-  if (!isDefaultCacheRoot(cacheRoot) && !existsSync2(path4.join(cacheRoot, CACHE_MARKER_FILE))) {
+  if (!isDefaultCacheRoot(cacheRoot) && !existsSync2(path5.join(cacheRoot, CACHE_MARKER_FILE))) {
     throw new Error(`Refusing to clear unmarked custom cache directory: ${cacheRoot}`);
   }
   await rm2(cacheRoot, { recursive: true, force: true });
@@ -53124,7 +53512,7 @@ async function commandCacheSearch(options) {
   const current = await readCurrentCache(cacheRoot);
   const corpusDir = typeof current?.corpusDir === "string" ? current.corpusDir : null;
   if (!corpusDir) throw new Error("No bundled SDK cache is available. Reinstall/update wave3d-agent-sdk.");
-  const indexPath = path4.join(corpusDir, "search", "minisearch-index.json");
+  const indexPath = path5.join(corpusDir, "search", "minisearch-index.json");
   const rawIndex = await readFile2(indexPath, "utf8");
   const miniSearch = MiniSearch2.loadJSON(rawIndex, {
     fields: ["title", "text"],