ATOM Documentation

<canvas id="term" width="800" height="600"></canvas>

// The AI "sees" the canvas by reading this array
const terminalState = {
  lines: [
    "Welcome to MyOS v1.0",
    "Type 'help' for commands...",
    "user@host:~$ _"
  ],
  cursorPos: 14,
  blinkState: true
};

<!-- Hidden accessibility tree (visually hidden but readable by agents) -->
<div
  role="log"
  aria-live="polite"
  aria-label="Terminal output"
  style="position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0, 0, 0, 0);"
  id="term-accessibility"
></div>

<canvas id="term" width="800" height="600"></canvas>

function updateAccessibilityMirror(terminalState) {
  const mirror = document.getElementById('term-accessibility');
  mirror.textContent = terminalState.lines.join('\n');
  mirror.setAttribute('aria-label', `Terminal: ${terminalState.lines.length} lines`);
}

{
  type: 'generic',
  elements: [
    { id: 1, elementType: 'rect', x: 100, y: 50, width: 200, height: 100, fill: 'blue' },
    { id: 2, elementType: 'text', content: 'Hello World', x: 150, y: 75 }
  ],
  viewport: { x: 0, y: 0, zoom: 1.0 },
  selection: null
}

{
  type: 'docs',
  content: 'Document content here...',
  cursor: { line: 5, column: 12 },
  selection: { start: { line: 3, column: 0 }, end: { line: 5, column: 12 } },
  metadata: { wordCount: 500, language: 'en' }
}

{
  type: 'email',
  to: ['user@example.com'],
  subject: 'Meeting Update',
  body: 'Hi,\n\nLet\'s meet tomorrow...',
  attachments: [],
  sending: false
}

{
  type: 'sheets',
  cells: {
    'A1': { value: 100, formula: '' },
    'B1': { value: 200, formula: '' },
    'C1': { value: 300, formula: '=SUM(A1:B1)' }
  },
  selection: 'A1',
  viewport: { startRow: 1, endRow: 20, startCol: 'A', endCol: 'Z' }
}

{
  type: 'orchestration',
  nodes: [
    { id: 1, nodeType: 'agent', x: 100, y: 50, label: 'Agent A', status: 'running' },
    { id: 2, nodeType: 'action', x: 300, y: 50, label: 'HTTP Request', config: {...} }
  ],
  connections: [
    { from: 1, to: 2, label: 'triggers' }
  ],
  selection: { nodeId: 2, port: 'output' },
  viewport: { x: 0, y: 0, zoom: 1.0 }
}

{
  type: 'terminal',
  lines: ["Welcome to MyOS v1.0", "Type 'help' for commands...", "user@host:~$ _"],
  cursorPos: 14,
  scrollOffset: 0,
  cursorBlink: true
}

{
  type: 'coding',
  files: [
    { path: '/src/main.ts', content: 'console.log("Hello");', language: 'typescript' }
  ],
  activeFile: '/src/main.ts',
  cursor: { line: 0, column: 26 },
  diagnostics: []
}

class CanvasContextExtractor:
    """Extract canvas state for episodic memory"""

    def extract_terminal_context(self, audit_records: List) -> Dict:
        """Extract terminal state (lines, cursor, scroll)"""
        return {
            "type": "terminal",
            "state": {
                "lines": self._get_lines(audit_records)[-100:],  # Last 100 lines
                "cursorPos": self._get_cursor_pos(audit_records),
                "scrollOffset": self._get_scroll_offset(audit_records)
            },
            "metadata": {
                "totalLines": len(self._get_lines(audit_records)),
                "hasErrors": self._check_errors(audit_records)
            }
        }

    def extract_editor_context(self, audit_records: List) -> Dict:
        """Extract editor state (nodes, connections, selections)"""
        return {
            "type": "editor",
            "state": {
                "nodes": self._get_nodes(audit_records)[-50:],  # Last 50 visible nodes
                "connections": self._get_connections(audit_records),
                "selection": self._get_selection(audit_records)
            },
            "metadata": {
                "nodeCount": len(self._get_nodes(audit_records)),
                "hasErrors": self._check_errors(audit_records)
            }
        }

CANVAS_PROMPTS = {
    'generic': """Analyze this generic canvas and provide a semantic summary:
    - Business context: What is being presented?
    - Intent: What decision is requested?
    - Key elements: What visual elements are present?
    - Data points: What critical information is shown?""",

    'docs': """Analyze this document canvas and provide a semantic summary:
    - Document purpose: What is this document about?
    - Key sections: What are the main sections?
    - Content summary: What are the key points?
    - Collaboration: Is this shared or being edited?""",

    'email': """Analyze this email canvas and provide a semantic summary:
    - Purpose: What is this email for?
    - Recipients: Who is it addressed to?
    - Key content: What is being communicated?
    - Attachments: What files are attached?
    - Action required: What response is needed?""",

    'sheets': """Analyze this spreadsheet canvas and provide a semantic summary:
    - Data purpose: What does this spreadsheet track?
    - Key metrics: What are the important numbers?
    - Trends: What patterns are visible?
    - Formulas: What calculations are performed?""",

    'orchestration': """Analyze this orchestration canvas and provide a semantic summary:
    - Workflow purpose: What does this workflow automate?
    - Key nodes: What are the important agents/actions?
    - Data flow: How does information flow through nodes?
    - Decision points: What human decisions are required?
    - Risks: What could go wrong?""",

    'terminal': """Analyze this terminal canvas and provide a semantic summary:
    - Context: What commands were executed?
    - Results: What output was produced?
    - Errors: Were there any errors?
    - Working directory: Where is this running?""",

    'coding': """Analyze this coding canvas and provide a semantic summary:
    - File purpose: What does this code do?
    - Language: What programming language?
    - Key functions: What are the main components?
    - Issues: Are there any errors or warnings?
    - Complexity: How complex is the code?"""
}

async def generate_presentation_summary(canvas_type: str, canvas_state: Dict) -> str:
    """Generate LLM-based semantic summary for canvas presentation"""

    prompt = CANVAS_PROMPTS[canvas_type]
    state_json = json.dumps(canvas_state, indent=2)

    full_prompt = f"""{prompt}

Canvas State:
{state_json}

Provide a 1-2 sentence semantic summary capturing business context, intent, and key information."""

    # Call LLM via BYOK handler
    summary = await llm_service.call(
        tenant_id,
        model="gpt-4o",
        messages=[{"role": "user", "content": full_prompt}]
    )

    return summary

Agent presented orchestration with line_chart

Agent presented $1.2M workflow approval requiring board consent with Q4 revenue trend chart
showing 15% growth, highlighting risks and requesting user decision.

class EpisodeService:
    async def recall_with_detail_level(
        self,
        task_description: str,
        detail_level: str = "summary"  # summary | standard | full
    ) -> List[Episode]:
        """Recall episodes with progressive detail levels"""

        # Summary: ~50 tokens (default)
        if detail_level == "summary":
            episodes = await self._recall_summary(task_description)

        # Standard: ~200 tokens (for decision-making)
        elif detail_level == "standard":
            episodes = await self._recall_standard(task_description)

        # Full: ~500 tokens (for deep analysis)
        elif detail_level == "full":
            episodes = await self._recall_full(task_description)

        return episodes

async def get_or_generate_summary(canvas_state: Dict) -> str:
    """Get cached summary or generate via LLM"""

    # Cache by state hash
    state_hash = hash(json.dumps(canvas_state, sort_keys=True))
    cache_key = f"canvas_summary:{state_hash}"

    # Try cache first (TTL: 1 hour)
    cached = await redis.get(cache_key)
    if cached:
        return cached

    # Generate via LLM
    try:
        summary = await generate_presentation_summary(
            canvas_state['type'],
            canvas_state
        )
        await redis.setex(cache_key, 3600, summary)  # 1 hour TTL
        return summary

    except LLMError:
        # Fallback to metadata extraction
        return extract_metadata_summary(canvas_state)