@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/apps/cad-creator/shared/cad/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@inneranimalmedia/agentsam-cad-shared",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.ts",
+    "./operations": "./src/domain/operations.ts",
+    "./validation": "./src/domain/validation.ts",
+    "./robotics": "./src/robotics/types.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "devDependencies": {
+    "typescript": "~5.8.2"
+  }
+}

package/apps/cad-creator/shared/cad/src/domain/operations.ts

@@ -0,0 +1,7 @@
+import { DesignProject, DesignOperation } from '../types';
+import { applyProjectOperation } from './project-contract.js';
+export interface ApplyOperationResult { project: DesignProject; success: boolean; error?: string; }
+export function applyDesignOperation(project: DesignProject, operation: DesignOperation): ApplyOperationResult {
+ try { return {success:true,project:applyProjectOperation(project,operation)}; }
+ catch(e:any) { return {success:false,project,error:e.message}; }
+}

package/apps/cad-creator/shared/cad/src/domain/project-contract.d.ts

@@ -0,0 +1,3 @@
+export function validateProject(project: any): {valid: boolean; errors: string[]};
+export function requireValidProject(project: any): any;
+export function applyProjectOperation(project: any, operation: any): any;

package/apps/cad-creator/shared/cad/src/domain/project-contract.js

@@ -0,0 +1,75 @@
+// Canonical editable CAD contract. Coordinates are inches; display units do not rescale geometry.
+export function validateProject(p) {
+  const errors = [];
+  if (!p || typeof p !== 'object') return {valid:false, errors:['project_required']};
+  if (!p.id || !p.name) errors.push('id_and_name_required');
+  if (p.scale !== 1) errors.push('coordinate_scale_must_be_one_inch');
+  const groups=['walls','rooms','doors','windows','furniture','annotations'];
+  const ids=new Set();
+  for (const group of groups) {
+    if (!Array.isArray(p[group])) { errors.push(group+'_array_required'); continue; }
+    for (const e of p[group]) {
+      if (!e || typeof e.id !== 'string' || !e.id || ids.has(e.id)) errors.push('invalid_or_duplicate_element_id');
+      else ids.add(e.id);
+    }
+  }
+  if(groups.some(g=>!Array.isArray(p[g])))return {valid:false,errors};
+  const finite=(v)=>typeof v==='number'&&Number.isFinite(v);
+  const positive=(v)=>finite(v)&&v>0;
+  for(const w of p.walls||[]) {
+    if (!w) continue;
+    if (![w.x1,w.y1,w.x2,w.y2].every(finite)||!positive(w.thickness)||!positive(w.height3D)||Math.hypot(w.x2-w.x1,w.y2-w.y1)<1e-6) errors.push('invalid_wall:'+w.id);
+  }
+  for(const e of [...(p.doors||[]),...(p.windows||[])]) {
+    if (!e) continue;
+    const w=(p.walls||[]).find(w=>w?.id===e.wallId);
+    if (!w) { errors.push('opening_wall_missing:'+e.id); continue; }
+    const len=Math.hypot(w.x2-w.x1,w.y2-w.y1), z=e.elevation??0;
+    if (!positive(e.width)||!positive(e.height)||!finite(e.distanceAlongWall)||e.distanceAlongWall<0||e.distanceAlongWall>1||!finite(z)||z<0||z+e.height>w.height3D||e.distanceAlongWall*len-e.width/2<0||e.distanceAlongWall*len+e.width/2>len) errors.push('opening_out_of_bounds:'+e.id);
+  }
+  for(const r of p.rooms||[]) if(!r||!Array.isArray(r.points)||r.points.length<3||!r.points.every(v=>Array.isArray(v)&&v.length===2&&v.every(finite))) errors.push('invalid_room:'+r?.id);
+  for(const f of p.furniture||[]) if(!f||![f.x,f.y,f.rotation].every(finite)||![f.w,f.d,f.h].every(positive)) errors.push('invalid_fixture:'+f?.id);
+  return {valid:errors.length===0,errors};
+}
+export function requireValidProject(p) {
+ const v=validateProject(p); if(!v.valid) throw new Error(v.errors.join('; ')); return p;
+}
+export function applyProjectOperation(project, operation) {
+ requireValidProject(project);
+ const next=structuredClone(project);
+ const apply=(op)=>{
+  if(!op||typeof op.type!=='string') throw new Error('operation_type_required');
+  if(op.type==='batch_operations'||op.type==='convert_sketch_selection') {
+   const list=op.operations??op.proposedOperations;
+   if(!Array.isArray(list)||list.length>256) throw new Error('invalid_operation_batch');
+   list.forEach(apply); return;
+  }
+  const specs={
+   create_wall:['walls','wall'], create_room:['rooms','room'], add_door:['doors','door'],add_window:['windows','window'],add_fixture:['furniture','fixture'],create_parametric_object:['parametricObjects','parametricObject']
+  };
+  if(specs[op.type]) {const [group,key]=specs[op.type]; if(!op[key])throw new Error(key+'_required'); (next[group]??=[]).push(structuredClone(op[key]));return;}
+  const updates={update_wall:['walls','wallId'],update_room:['rooms','roomId'],update_door:['doors','doorId'],update_window:['windows','windowId'],update_fixture:['furniture','fixtureId']};
+  const deletes={delete_wall:['walls','wallId'],delete_room:['rooms','roomId'],delete_door:['doors','doorId'],delete_window:['windows','windowId'],delete_fixture:['furniture','fixtureId'],delete_parametric_object:['parametricObjects','parametricObjectId']};
+  const find=(group,id)=>{const e=(next[group]||[]).find(e=>e.id===id);if(!e)throw new Error('element_not_found:'+id);return e;};
+  if(updates[op.type]){const [g,k]=updates[op.type];const e=find(g,op[k]);if(!op.updates||('id' in op.updates&&op.updates.id!==e.id))throw new Error('invalid_updates');Object.assign(e,op.updates);return;}
+  if(deletes[op.type]){const [g,k]=deletes[op.type];find(g,op[k]);next[g]=next[g].filter(e=>e.id!==op[k]);if(g==='walls'){next.doors=next.doors.filter(e=>e.wallId!==op[k]);next.windows=next.windows.filter(e=>e.wallId!==op[k]);}return;}
+  if(op.type==='move_element'){
+   if(!Number.isFinite(op.dx)||!Number.isFinite(op.dy))throw new Error('finite_displacement_required');
+   const g={wall:'walls',room:'rooms',furniture:'furniture',parametric:'parametricObjects'}[op.elementType];
+   if(!g)throw new Error('unsupported_move_type:'+op.elementType);
+   const e=find(g,op.elementId);
+   if(g==='walls'){e.x1+=op.dx;e.x2+=op.dx;e.y1+=op.dy;e.y2+=op.dy;}
+   else if(g==='rooms') e.points=e.points.map(([x,y])=>[x+op.dx,y+op.dy]);
+   else if(g==='parametricObjects'){e.transform.x+=op.dx;e.transform.y+=op.dy;e.transform.z+=op.dz??0;}
+   else {e.x+=op.dx;e.y+=op.dy;}return;
+  }
+  if(op.type==='set_lighting'){next.lighting={...next.lighting,...op.lighting};return;}
+  if(op.type==='attach_sketch'){next.sketchDocument=structuredClone(op.sketchDocument);return;}
+  if(op.type==='update_parametric_parameter'){const e=find('parametricObjects',op.parametricObjectId);e.parameters[op.parameterName]=op.value;return;}
+  if(op.type==='update_parametric_source'){find('parametricObjects',op.parametricObjectId).source=op.source;return;}
+  throw new Error('unsupported_operation:'+op.type);
+ };
+ apply(operation);requireValidProject(next);
+ next.version=(project.version||1)+1;next.updatedAt=Date.now();
+ return next;
+}

package/apps/cad-creator/shared/cad/src/domain/project-tools.d.ts

@@ -0,0 +1 @@
+export const CAD_PROJECT_TOOLS: any[];

package/apps/cad-creator/shared/cad/src/domain/project-tools.js

@@ -0,0 +1,24 @@
+export const CAD_PROJECT_TOOLS = [
+ ['design_project_get','Read an editable CAD project revision','design.read'],
+ ['design_project_validate','Validate inch-based CAD project geometry and references','design.read'],
+ ['design_apply_operation','Apply an atomic typed edit with revision conflict detection','design.write'],
+ ['design_project_save','Save an immutable CAD project revision','design.write'],
+ ['design_project_restore','Restore saved geometry as a new revision','design.write'],
+ ['design_model_build','Build a real Blender model from an editable CAD project','design.write'],
+ ['design_model_inspect','Inspect a verified revision model','design.read'],
+ ['design_model_render','Render a courtyard PNG from a revision model','design.export'],
+ ['design_model_export','Export a revision model as GLB STL or OBJ','design.export']
+].map(([name,description,capability_key])=>{
+ const fields={
+ expected_content_hash:{type:'string',pattern:'^[a-f0-9]{64}$'},project_id:{type:'string',pattern:'^[A-Za-z0-9_-]{1,100}$'},revision:{type:'integer',minimum:1},expected_revision:{type:'integer',minimum:0},
+ project:{type:'object',additionalProperties:true},operation:{type:'object',properties:{type:{type:'string'}},required:['type'],additionalProperties:true},format:{type:'string',enum:['glb','stl','obj']},message:{type:'string',maxLength:2000}};
+ const allowed=name==='design_project_get'?['project_id','revision','expected_content_hash']:name==='design_project_save'?['project','expected_revision','message']:
+ name==='design_project_validate'?['project','project_id','revision']:
+ name==='design_apply_operation'?['project_id','expected_revision','operation','message']:
+ name==='design_project_restore'?['project_id','revision','expected_revision']:
+ name==='design_model_export'?['project_id','revision','format']:['project_id','revision'];
+ const required=name==='design_project_validate'?[]:name==='design_project_save'?['project','expected_revision']:
+ name==='design_apply_operation'?['project_id','expected_revision','operation']:
+ name==='design_project_restore'?['project_id','revision','expected_revision']:['project_id'];
+ return {name,description,capability_key,strict:false,input_schema:{type:'object',properties:Object.fromEntries(allowed.map(k=>[k,fields[k]])),required,additionalProperties:false},output_schema:{type:'object'}};
+});

package/apps/cad-creator/shared/cad/src/domain/validation.ts

@@ -0,0 +1,191 @@
+import { DesignProject, DesignOperation } from '../types';
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+export function validateDesignProject(data: any): ValidationResult {
+  const errors: string[] = [];
+
+  if (!data || typeof data !== 'object') {
+    return { valid: false, errors: ['Project state must be an object'] };
+  }
+
+  if (typeof data.id !== 'string' || !data.id.trim()) {
+    errors.push('Project must have a valid non-empty id');
+  }
+
+  if (typeof data.name !== 'string') {
+    errors.push('Project name must be a string');
+  }
+
+  if (!Array.isArray(data.walls)) {
+    errors.push('Project walls must be an array');
+  } else {
+    data.walls.forEach((w: any, i: number) => {
+      if (typeof w.x1 !== 'number' || typeof w.y1 !== 'number' || typeof w.x2 !== 'number' || typeof w.y2 !== 'number') {
+        errors.push(`Wall at index ${i} has invalid coordinates (x1, y1, x2, y2 must be numbers)`);
+      }
+      if (w.x1 === w.x2 && w.y1 === w.y2) {
+        errors.push(`Wall at index ${i} has zero length`);
+      }
+    });
+  }
+
+  if (!Array.isArray(data.rooms)) {
+    errors.push('Project rooms must be an array');
+  } else {
+    data.rooms.forEach((r: any, i: number) => {
+      if (!Array.isArray(r.points) || r.points.length < 3) {
+        errors.push(`Room at index ${i} must have at least 3 vertices`);
+      }
+    });
+  }
+
+  if (!Array.isArray(data.doors)) {
+    errors.push('Project doors must be an array');
+  }
+
+  if (!Array.isArray(data.windows)) {
+    errors.push('Project windows must be an array');
+  }
+
+  if (!Array.isArray(data.furniture)) {
+    errors.push('Project furniture must be an array');
+  }
+
+  if (data.parametricObjects && !Array.isArray(data.parametricObjects)) {
+    errors.push('Project parametricObjects must be an array if provided');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+export function validateDesignOperation(op: any): ValidationResult {
+  const errors: string[] = [];
+
+  if (!op || typeof op !== 'object') {
+    return { valid: false, errors: ['Operation must be an object'] };
+  }
+
+  if (!op.type || typeof op.type !== 'string') {
+    errors.push('Operation must have a valid type');
+    return { valid: false, errors };
+  }
+
+  switch (op.type) {
+    case 'create_wall':
+      if (!op.wall || typeof op.wall !== 'object') {
+        errors.push('create_wall must include wall object');
+      } else if (op.wall.x1 === op.wall.x2 && op.wall.y1 === op.wall.y2) {
+        errors.push('create_wall cannot create zero-length wall');
+      }
+      break;
+
+    case 'update_wall':
+      if (!op.wallId || typeof op.wallId !== 'string') {
+        errors.push('update_wall requires wallId');
+      }
+      if (!op.updates || typeof op.updates !== 'object') {
+        errors.push('update_wall requires updates object');
+      }
+      break;
+
+    case 'delete_wall':
+      if (!op.wallId || typeof op.wallId !== 'string') {
+        errors.push('delete_wall requires wallId');
+      }
+      break;
+
+    case 'create_room':
+      if (!op.room || !Array.isArray(op.room.points) || op.room.points.length < 3) {
+        errors.push('create_room requires room with at least 3 polygon points');
+      }
+      break;
+
+    case 'add_door':
+      if (!op.door || !op.door.wallId) {
+        errors.push('add_door requires door with valid wallId');
+      }
+      break;
+
+    case 'add_window':
+      if (!op.window || !op.window.wallId) {
+        errors.push('add_window requires window with valid wallId');
+      }
+      break;
+
+    case 'create_parametric_object':
+      if (!op.parametricObject || !op.parametricObject.id || !op.parametricObject.generator) {
+        errors.push('create_parametric_object requires id and generator');
+      }
+      break;
+
+    case 'update_parametric_parameter':
+      if (!op.parametricObjectId || !op.parameterName) {
+        errors.push('update_parametric_parameter requires parametricObjectId and parameterName');
+      }
+      break;
+
+    case 'batch_operations':
+      if (!Array.isArray(op.operations)) {
+        errors.push('batch_operations requires operations array');
+      }
+      break;
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+export function sanitizeDesignProject(raw: Partial<DesignProject> | any): DesignProject {
+  const now = Date.now();
+  return {
+    id: typeof raw?.id === 'string' && raw.id ? raw.id : `proj_${now}`,
+    name: typeof raw?.name === 'string' && raw.name ? raw.name : 'Untitled Spatial Design',
+    units: raw?.units === 'mm' || raw?.units === 'm' || raw?.units === 'ft' ? raw.units : 'in',
+    scale: typeof raw?.scale === 'number' ? raw.scale : 1,
+    gridSize: typeof raw?.gridSize === 'number' ? raw.gridSize : 12,
+    snapToGrid: typeof raw?.snapToGrid === 'boolean' ? raw.snapToGrid : true,
+    layers: Array.isArray(raw?.layers) ? raw.layers : [
+      { id: 'walls', name: 'Walls & Structure', visible: true, locked: false, color: '#3b82f6' },
+      { id: 'doors', name: 'Doors & Windows', visible: true, locked: false, color: '#06b6d4' },
+      { id: 'rooms', name: 'Room Flooring', visible: true, locked: false, color: '#10b981' },
+      { id: 'furniture', name: 'Furniture & Fixtures', visible: true, locked: false, color: '#f59e0b' },
+      { id: 'parametric', name: 'Parametric Objects', visible: true, locked: false, color: '#8b5cf6' },
+      { id: 'sketches', name: 'Sketches & Annotations', visible: true, locked: false, color: '#ec4899' },
+    ],
+    walls: Array.isArray(raw?.walls) ? raw.walls : [],
+    doors: Array.isArray(raw?.doors) ? raw.doors : [],
+    windows: Array.isArray(raw?.windows) ? raw.windows : [],
+    furniture: Array.isArray(raw?.furniture) ? raw.furniture : [],
+    rooms: Array.isArray(raw?.rooms) ? raw.rooms : [],
+    annotations: Array.isArray(raw?.annotations) ? raw.annotations : [],
+    parametricObjects: Array.isArray(raw?.parametricObjects) ? raw.parametricObjects : [],
+    sketchDocument: raw?.sketchDocument || undefined,
+    lighting: raw?.lighting || {
+      sunAltitude: 45,
+      sunAzimuth: 135,
+      intensity: 1.1,
+      timeOfDay: 'noon',
+      shadows: true,
+      ambientColor: '#334155',
+    },
+    roofType: raw?.roofType || 'none',
+    ceilingHeight: typeof raw?.ceilingHeight === 'number' ? raw.ceilingHeight : 96,
+    metadata: raw?.metadata || {
+      createdAt: now,
+      updatedAt: now,
+      revision: 1,
+      author: 'AgentSam Architect',
+    },
+    updatedAt: typeof raw?.updatedAt === 'number' ? raw.updatedAt : now,
+    version: typeof raw?.version === 'number' ? raw.version : 1,
+  };
+}

package/apps/cad-creator/shared/cad/src/index.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './domain/operations';
+export * from './domain/validation';
+export * from './robotics/types';

package/apps/cad-creator/shared/cad/src/robotics/types.ts

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * 3D Spatial Vector
+ */
+export interface Vector3D {
+  x: number;
+  y: number;
+  z: number;
+}
+
+/**
+ * 4D Quaternion Orientation [x, y, z, w]
+ */
+export interface Quaternion4D {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+/**
+ * Euler Angles in Degrees or Radians [roll, pitch, yaw]
+ */
+export interface EulerAngles {
+  roll: number;
+  pitch: number;
+  yaw: number;
+}
+
+/**
+ * Canonical 6-DOF Spatial Pose
+ */
+export interface Pose {
+  position: Vector3D;
+  orientation: Quaternion4D;
+  eulerDeg?: EulerAngles;
+  frameId?: string;
+  timestamp?: number;
+}
+
+/**
+ * Canonical Joint State for an Actuated Degree of Freedom
+ */
+export interface JointState {
+  jointIndex: number;
+  name: string;
+  positionRad: number;
+  velocityRadPerSec: number;
+  effortNm: number;
+  limits?: {
+    minRad: number;
+    maxRad: number;
+    maxVelRadPerSec: number;
+    maxTorqueNm: number;
+  };
+}
+
+/**
+ * Canonical Robot Instance domain model
+ */
+export interface RobotInstance {
+  id: string;
+  definitionId: string;
+  name: string;
+  manufacturer: string;
+  dof: number;
+  payloadKg: number;
+  reachMm: number;
+  gripperType: string;
+  basePose: Pose;
+  tcpPose: Pose;
+  jointStates: JointState[];
+  gripperOpenAmount: number; // 0 (closed) to 1 (fully open)
+  gripperForceN: number;
+  status: 'idle' | 'executing' | 'error' | 'paused' | 'holding';
+  activeTrajectoryId?: string;
+}
+
+/**
+ * Robot Model Specification Definition
+ */
+export interface RobotDefinition {
+  id: string;
+  name: string;
+  manufacturer: string;
+  dof: number;
+  payloadKg: number;
+  reachMm: number;
+  gripperType: string;
+  sceneFile: string;
+  description: string;
+  jointNames?: string[];
+  homeJointPositions?: number[];
+  defaultTcpOffset?: Vector3D;
+}
+
+/**
+ * 2D Bounding Box in Normalized Coordinates [ymin, xmin, ymax, xmax] (0 - 1000)
+ */
+export type BoundingBox2D = [number, number, number, number];
+
+/**
+ * 2D Point in Normalized Coordinates [y, x] (0 - 1000)
+ */
+export type Point2D = [number, number];
+
+/**
+ * Canonical Perception / Detection Result from Vision-Language-Action Models
+ */
+export interface DetectionResult {
+  id: string;
+  label: string;
+  confidence?: number;
+  box_2d?: BoundingBox2D;
+  point?: Point2D;
+  worldPosition?: Vector3D;
+  targetMarkerId?: number;
+  category?: string;
+  attributes?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Canonical Simulation Telemetry for real-time physics & diagnostics
+ */
+export interface SimulationTelemetry {
+  timestamp: number;
+  simTime: number;
+  fps: number;
+  stepRateHz: number;
+  realTimeFactor: number;
+  gripperForce: number;
+  gripperCtrl: number;
+  jointVelocities: number[];
+  jointPositions: number[];
+  maxJointVelocity: number;
+  rmsJointVelocity: number;
+  collisionCount: number;
+  robotContacts: number;
+  environmentContacts: number;
+  endEffectorPos: Vector3D;
+  endEffectorVel: number;
+  simulationStatus: 'running' | 'paused' | 'picking' | 'ik_active' | 'idle';
+}
+
+/**
+ * Historical telemetry sample for sparkline charts and trend analysis
+ */
+export interface TelemetryHistoryPoint {
+  timestamp: number;
+  fps: number;
+  stepRateHz: number;
+  collisionCount: number;
+  robotContacts: number;
+  environmentContacts: number;
+  gripperForce: number;
+  maxJointVelocity: number;
+  endEffectorVel: number;
+}
+
+/**
+ * Summary trend metrics derived from historical telemetry stream
+ */
+export interface SimulationTrendMetrics {
+  avgFps: number;
+  minFps: number;
+  maxFps: number;
+  peakForce: number;
+  peakVelocity: number;
+  totalCollisions: number;
+  activeContacts: number;
+}
+
+/**
+ * Alias for canonical simulation telemetry data model
+ */
+export type SimulationTelemetryData = SimulationTelemetry;
+
+/**
+ * Grasp & Manipulation Target Specification
+ */
+export interface GraspTarget {
+  id: string;
+  targetMarkerId: number;
+  label: string;
+  approachPose: Pose;
+  graspPose: Pose;
+  liftPose: Pose;
+  destinationPose?: Pose;
+  gripForceN: number;
+  status: 'pending' | 'approaching' | 'grasping' | 'lifting' | 'placed' | 'failed';
+}
+
+/**
+ * Trajectory Waypoint in Cartesian Space
+ */
+export interface CartesianWaypoint {
+  pose: Pose;
+  linearVelocity?: number;
+  timeFromStartSec: number;
+  blendRadiusMm?: number;
+}
+
+/**
+ * Trajectory Plan in Cartesian or Joint Space
+ */
+export interface CartesianTrajectory {
+  id: string;
+  robotId: string;
+  waypoints: CartesianWaypoint[];
+  totalDurationSec: number;
+  interpolation: 'linear' | 'cubic_spline' | 'quintic';
+  isGripAction?: boolean;
+}
+
+/**
+ * Embodied Reasoning Vision Task
+ */
+export interface EmbodiedReasoningTask {
+  id: string;
+  timestamp: Date;
+  prompt: string;
+  fullPrompt: string;
+  detectionType: '2D bounding boxes' | 'Points';
+  imageSnapshotBase64: string;
+  detections: DetectionResult[];
+  status: 'idle' | 'processing' | 'success' | 'error';
+  errorMessage?: string;
+}