@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/services/cad/server.py

@@ -37,6 +37,8 @@ TOOL_COMMANDS = {
 }
 
 OPENSCAD_FORMATS = {"stl", "3mf", "dxf", "svg", "csg", "off", "amf"}
+FREECAD_FORMATS = {"step", "stp", "iges", "brep", "stl"}
+BLENDER_FORMATS = {"glb", "stl", "obj", "png"}
 FORBIDDEN_OPENSCAD = [
     (re.compile(r"\binclude\s*<", re.I), "include directives are disabled"),
     (re.compile(r"\buse\s*<", re.I), "use directives are disabled"),
@@ -83,8 +85,8 @@ def _capabilities() -> dict[str, Any]:
         "tools": tools,
         "endpoints": {
             "openscad_compile": tools["openscad"]["installed"],
-            "freecad_execute": False,
-            "blender_execute": False,
+            "freecad_execute": tools["freecad"]["installed"],
+            "blender_execute": tools["blender"]["installed"],
         },
         "limits": {
             "max_source_chars": MAX_SOURCE_CHARS,
@@ -202,6 +204,245 @@ def _compile_openscad(payload: dict[str, Any]) -> dict[str, Any]:
         }
 
 
+def _find_freecad_adapter() -> Path:
+    candidates = [
+        Path("/srv/freecad/adapter.py"),
+        Path("/srv/services/cad/freecad/adapter.py"),
+        Path(__file__).parent / "freecad" / "adapter.py",
+        Path(__file__).parent / "freecad_adapter.py",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+    raise RuntimeError("FreeCAD adapter script not found in CAD service container")
+
+
+def _find_blender_adapter() -> Path:
+    candidates = [
+        Path("/srv/blender/adapter.py"),
+        Path("/srv/services/cad/blender/adapter.py"),
+        Path(__file__).parent / "blender" / "adapter.py",
+        Path(__file__).parent / "blender_adapter.py",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+    raise RuntimeError("Blender adapter script not found in CAD service container")
+
+
+def _freecad_command(adapter_path: Path, request_path: Path, operation: str = "build") -> list[str]:
+    for cmd in ["FreeCADCmd", "freecadcmd", "/usr/lib/freecad/bin/FreeCADCmd"]:
+        binary = shutil.which(cmd)
+        if binary or Path(cmd).exists():
+            return [binary or cmd, str(adapter_path), "--operation", operation, "--request", str(request_path)]
+    for py in ["/usr/lib/freecad/bin/python", "python3"]:
+        binary = shutil.which(py)
+        if binary or Path(py).exists():
+            return [binary or py, str(adapter_path), "--operation", operation, "--request", str(request_path)]
+    raise RuntimeError("FreeCAD runtime binary not found in container")
+
+
+def _blender_command(adapter_path: Path, request_path: Path, operation: str = "build") -> list[str]:
+    for cmd in ["blender", "/usr/bin/blender", "/usr/local/bin/blender"]:
+        binary = shutil.which(cmd)
+        if binary or Path(cmd).exists():
+            return [binary or cmd, "-b", "--python", str(adapter_path), "--", "--operation", operation, "--request", str(request_path)]
+    raise RuntimeError("Blender runtime binary not found in container")
+
+
+def _execute_freecad(payload: dict[str, Any]) -> dict[str, Any]:
+    adapter_path = _find_freecad_adapter()
+    operations = payload.get("operations") or (payload.get("recipe", {}).get("operations") if isinstance(payload.get("recipe"), dict) else None)
+    if not isinstance(operations, list) or len(operations) == 0:
+        raise ValueError("operations must be a non-empty list of modeling operations")
+    if len(operations) > 256:
+        raise ValueError("operations list exceeds maximum limit of 256")
+
+    output_format = str(payload.get("format", "step")).lower().lstrip(".")
+    if output_format not in FREECAD_FORMATS:
+        raise ValueError(f"unsupported FreeCAD format: {output_format}")
+
+    timeout = payload.get("timeout_seconds", 30)
+    try:
+        timeout = int(timeout)
+    except (TypeError, ValueError):
+        timeout = 30
+    timeout = max(1, min(timeout, MAX_TIMEOUT_SECONDS))
+
+    filename = str(payload.get("filename") or f"model.{output_format}")
+    filename = re.sub(r"[^A-Za-z0-9._-]+", "_", Path(filename).name)[:160] or f"model.{output_format}"
+    if not filename.lower().endswith(f".{output_format}"):
+        filename += f".{output_format}"
+
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="freecad-", dir=WORK_ROOT) as temp:
+        temp_path = Path(temp)
+        output_path = temp_path / filename
+        request_path = temp_path / "request.json"
+
+        request_data = {
+            "schema_version": 1,
+            "output": str(output_path),
+            "format": output_format,
+            "operations": operations,
+        }
+        request_path.write_text(json.dumps(request_data, indent=2), encoding="utf-8")
+
+        command = _freecad_command(adapter_path, request_path, operation="build")
+        env = os.environ.copy()
+        env.setdefault("QT_QPA_PLATFORM", "offscreen")
+        env.setdefault("PYTHONPATH", "/usr/lib/freecad/lib")
+
+        try:
+            proc = subprocess.run(
+                command,
+                cwd=temp,
+                env=env,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError(f"FreeCAD execution exceeded {timeout}s") from exc
+
+        stdout = proc.stdout or ""
+        stderr = proc.stderr or ""
+        logs = (stdout + "\n" + stderr).strip()
+
+        result_envelope = None
+        for line in reversed(stdout.splitlines()):
+            if line.startswith("AGENTSAM_RESULT="):
+                try:
+                    result_envelope = json.loads(line[len("AGENTSAM_RESULT="):])
+                    break
+                except json.JSONDecodeError:
+                    pass
+
+        if not result_envelope or not result_envelope.get("ok"):
+            err_msg = result_envelope.get("error") if result_envelope else f"exit {proc.returncode}"
+            raise RuntimeError(f"FreeCAD modeling failed ({err_msg}): {logs[-4000:]}")
+
+        if not output_path.exists():
+            raise RuntimeError(f"FreeCAD failed to produce output file {filename}")
+
+        artifact = output_path.read_bytes()
+        if len(artifact) > MAX_ARTIFACT_BYTES:
+            raise RuntimeError(f"artifact is {len(artifact)} bytes; exceeds {MAX_ARTIFACT_BYTES} bytes")
+
+        digest = hashlib.sha256(artifact).hexdigest()
+
+        return {
+            "ok": True,
+            "tool": "freecad",
+            "format": output_format,
+            "filename": filename,
+            "size_bytes": len(artifact),
+            "sha256": digest,
+            "artifact_base64": base64.b64encode(artifact).decode("ascii"),
+            "metrics": result_envelope.get("metrics", {}),
+            "logs": logs[-8000:],
+        }
+
+
+def _execute_blender(payload: dict[str, Any]) -> dict[str, Any]:
+    adapter_path = _find_blender_adapter()
+    operation = str(payload.get("operation") or "build").lower()
+    if operation not in ("build", "inspect", "render_preview", "export"):
+        raise ValueError(f"unsupported Blender operation: {operation}")
+
+    recipe = payload.get("recipe")
+    if recipe is None and "operations" in payload:
+        recipe = {"schema_version": 1, "operations": payload["operations"]}
+    if not isinstance(recipe, dict):
+        raise ValueError("recipe must be an object")
+
+    output_format = str(payload.get("format", "glb")).lower().lstrip(".")
+    if output_format not in BLENDER_FORMATS:
+        raise ValueError(f"unsupported Blender format: {output_format}")
+
+    timeout = payload.get("timeout_seconds", 30)
+    try:
+        timeout = int(timeout)
+    except (TypeError, ValueError):
+        timeout = 30
+    timeout = max(1, min(timeout, MAX_TIMEOUT_SECONDS))
+
+    filename = str(payload.get("filename") or f"model.{output_format}")
+    filename = re.sub(r"[^A-Za-z0-9._-]+", "_", Path(filename).name)[:160] or f"model.{output_format}"
+    if not filename.lower().endswith(f".{output_format}"):
+        filename += f".{output_format}"
+
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="blender-", dir=WORK_ROOT) as temp:
+        temp_path = Path(temp)
+        output_path = temp_path / filename
+        request_path = temp_path / "request.json"
+
+        request_data = {
+            "schema_version": 1,
+            "output": str(output_path),
+            "format": output_format,
+            **recipe,
+        }
+        request_path.write_text(json.dumps(request_data, indent=2), encoding="utf-8")
+
+        command = _blender_command(adapter_path, request_path, operation=operation)
+        env = os.environ.copy()
+        env.setdefault("HOME", "/tmp/home")
+
+        try:
+            proc = subprocess.run(
+                command,
+                cwd=temp,
+                env=env,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError(f"Blender execution exceeded {timeout}s") from exc
+
+        stdout = proc.stdout or ""
+        stderr = proc.stderr or ""
+        logs = (stdout + "\n" + stderr).strip()
+
+        result_envelope = None
+        for line in reversed(stdout.splitlines()):
+            if line.startswith("AGENTSAM_RESULT="):
+                try:
+                    result_envelope = json.loads(line[len("AGENTSAM_RESULT="):])
+                    break
+                except json.JSONDecodeError:
+                    pass
+
+        if not result_envelope or not result_envelope.get("ok"):
+            err_msg = result_envelope.get("error") if result_envelope else f"exit {proc.returncode}"
+            raise RuntimeError(f"Blender execution failed ({err_msg}): {logs[-4000:]}")
+
+        artifact = b""
+        if output_path.exists():
+            artifact = output_path.read_bytes()
+            if len(artifact) > MAX_ARTIFACT_BYTES:
+                raise RuntimeError(f"artifact is {len(artifact)} bytes; exceeds {MAX_ARTIFACT_BYTES} bytes")
+
+        digest = hashlib.sha256(artifact).hexdigest() if artifact else None
+
+        return {
+            "ok": True,
+            "tool": "blender",
+            "operation": operation,
+            "format": output_format,
+            "filename": filename if artifact else None,
+            "size_bytes": len(artifact),
+            "sha256": digest,
+            "artifact_base64": base64.b64encode(artifact).decode("ascii") if artifact else None,
+            "result": result_envelope,
+            "logs": logs[-8000:],
+        }
+
+
 class Handler(BaseHTTPRequestHandler):
     server_version = "AgentSamCAD/1"
 
@@ -262,6 +503,12 @@ class Handler(BaseHTTPRequestHandler):
             if self.path == "/v1/openscad/compile":
                 self._json(HTTPStatus.OK, _compile_openscad(payload))
                 return
+            if self.path == "/v1/freecad/execute":
+                self._json(HTTPStatus.OK, _execute_freecad(payload))
+                return
+            if self.path == "/v1/blender/execute":
+                self._json(HTTPStatus.OK, _execute_blender(payload))
+                return
             self._json(HTTPStatus.NOT_FOUND, {"ok": False, "error": "not_found"})
         except ValueError as exc:
             self._json(HTTPStatus.BAD_REQUEST, {"ok": False, "error": str(exc)})

package/src/agent/capability-adapter.js

@@ -1,15 +1,19 @@
 import fs from 'node:fs';
+import { CAD_PROJECT_TOOLS } from '../lib/cad/project-runtime.js';
+import { localProjectRuntime } from '../lib/cad/project-cli.js';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getCapability, listCapabilities } from '../capabilities/manifest.js';
 import { repositorySnapshot } from '../capabilities/repository-snapshot.js';
 import { runWranglerNative, summarizeCloudflareCpuProfileFile, runCloudflareCpuAudit } from '../cloudflare/index.js';
 import { runRepositoryAudit } from './repository-audit.js';
+import { terminalExec } from '../capabilities/terminal-exec.js';
+import { runKnowledgeSearch } from '../commands/knowledge.js';
 
 const PACKAGE_ROOT = path.resolve(fileURLToPath(new URL('../../', import.meta.url)));
 
 function loadSchema(value) {
-  if (!value) return { type: 'object', properties: {} };
+  if (!value) return { type: 'object', properties: {}, required: [], additionalProperties: false };
   if (typeof value === 'object' && !Array.isArray(value)) return structuredClone(value);
   const filename = path.resolve(PACKAGE_ROOT, String(value));
   if (filename !== PACKAGE_ROOT && !filename.startsWith(`${PACKAGE_ROOT}${path.sep}`)) throw new Error(`capability_schema_outside_package:${value}`);
@@ -17,11 +21,16 @@ function loadSchema(value) {
   catch (error) { throw new Error(`capability_schema_unreadable:${value}:${error?.message || error}`); }
 }
 
-export function createCapabilityAdapter({ handlers = {}, reasoner } = {}) {
+export function createCapabilityAdapter({ handlers = {}, reasoner, projectRoot = process.cwd() } = {}) {
+  const cad = localProjectRuntime(projectRoot);
+  const cadDescriptors = CAD_PROJECT_TOOLS.map(t=>({...t,id:t.name,version:'1.0.0',domain:'design',kind:'tool',status:'active',side_effects:['design_project_get','design_project_validate','design_model_inspect'].includes(t.name)?'none':'filesystem-write',deterministic:true,model_required:false}));
   const executable = new Map([
     ['repository.snapshot', (input) => repositorySnapshot(input)],
+    ['terminal.exec', (input = {}) => terminalExec(input)],
     ['cloudflare.wrangler.native', (input = {}) => runWranglerNative(input.command, input)],
     ['cloudflare.cpu.profile', (input = {}) => summarizeCloudflareCpuProfileFile(input)],
+    ['knowledge.search', (input = {}) => runKnowledgeSearch(input)],
+    ...cadDescriptors.map(t=>[t.id,(input)=>cad.execute(t.id,input)]),
     ...Object.entries(handlers),
   ]);
   if (typeof reasoner === 'function') {
@@ -30,21 +39,22 @@ export function createCapabilityAdapter({ handlers = {}, reasoner } = {}) {
   }
 
   function describe(id) {
-    const capability = getCapability(id);
+    const capability = cadDescriptors.find(t=>t.id===id) || getCapability(id);
     if (!capability) throw new Error(`unknown_capability:${id}`);
     return capability;
   }
 
   return Object.freeze({
-    list(options = {}) { return listCapabilities(options); },
+    list(options = {}) { return [...listCapabilities(options),...cadDescriptors.filter(t=>(!options.domain||options.domain==='design')&&(!options.kind||options.kind==='tool')&&(!options.status||options.status==='active'))]; },
     describe,
     toolDescriptors({ domain, kind, includeUnavailable = false } = {}) {
-      return listCapabilities({ domain, kind, status: null }).filter((row) => includeUnavailable || executable.has(row.id)).map((row) => ({
+      return [...listCapabilities({ domain, kind, status: null }), ...cadDescriptors.filter(t=>(!domain||domain==='design')&&(!kind||kind==='tool'))].filter((row) => includeUnavailable || executable.has(row.id)).map((row) => ({
         name: row.id,
         description: row.description,
         category: row.domain,
         risk: row.side_effects === 'none' || row.side_effects === 'network-read' ? 'read' : 'write',
         input_schema: loadSchema(row.input_schema),
+        strict: row.strict !== false,
         side_effects: row.side_effects,
         deterministic: row.deterministic,
         model_required: row.model_required,

package/src/agent/index.js

@@ -1,3 +1,4 @@
 export { createCapabilityAdapter } from './capability-adapter.js';
 export { buildRepositoryAuditPacket, renderRepositoryAuditMarkdown, runRepositoryAudit } from './repository-audit.js';
-export { buildAgentToolSurface, capabilityFunctionName, runResponsesAgent } from './responses-runner.js';
+export { runAgentSamModelTurn } from './model-turn.js';
+export { buildAgentToolSurface, capabilityFunctionName, runAgentSamTurn, runResponsesAgent } from './responses-runner.js';

package/src/agent/model-turn.js

@@ -0,0 +1,51 @@
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function normalizeToolCall(call = {}) {
+  const args = call.arguments == null
+    ? '{}'
+    : typeof call.arguments === 'string'
+      ? call.arguments
+      : JSON.stringify(call.arguments);
+  return Object.freeze({
+    id: clean(call.call_id || call.id) || null,
+    name: clean(call.name),
+    arguments: args,
+  });
+}
+
+/**
+ * Provider-only AgentSam inference boundary.
+ *
+ * This function never resolves accounts, touches D1, authorizes a tool, or
+ * executes a tool. Provider adapters own wire-format translation and this
+ * function normalizes their result for the orchestration runtime.
+ */
+export async function runAgentSamModelTurn(options = {}) {
+  const provider = options.provider;
+  if (!provider?.create || !provider?.continueWithToolOutputs) {
+    throw new TypeError('AgentSam provider adapter is required');
+  }
+
+  const continuation = Array.isArray(options.toolOutputs) && options.toolOutputs.length > 0;
+  const response = continuation
+    ? await provider.continueWithToolOutputs(options)
+    : await provider.create(options);
+  const toolCalls = Object.freeze((response.tool_calls || []).map(normalizeToolCall));
+
+  return Object.freeze({
+    type: toolCalls.length ? 'tool_calls' : 'assistant',
+    content: clean(response.output_text),
+    tool_calls: toolCalls,
+    provider: clean(response.provider || options.modelRecord?.provider) || null,
+    model: clean(response.model || options.model || options.modelRecord?.provider_model_id) || null,
+    usage: response.usage_snapshot || response.usage_delta || null,
+    response_id: response.response_id || null,
+    provider_state: response.provider_state || null,
+    requested_service_tier: response.requested_service_tier || null,
+    actual_service_tier: response.actual_service_tier || null,
+    cost: response.cost || null,
+    raw: response,
+  });
+}