@archetypeai/ds-cli 0.3.9 → 0.3.11

package/files/skills/newton-camera-frame-analysis/scripts/activity-monitor-frame.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Simplified webcam capture and analysis using ArchetypeAI Newton model
+"""
+import cv2
+import base64
+import os
+import sys
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from archetypeai.api_client import ArchetypeAI
+from archetypeai.utils import base64_encode
+
+# Model configuration - defined once and reused
+MODEL_CONFIG = {
+    "model_version": "Newton::c2_4_7b_251215a172f6d7",
+    "template_name": "image_qa_template_task",
+    "instruction": "Answer the following question about the image:",
+    "max_new_tokens": 512
+}
+
+def capture_webcam_image(camera_index=0, output_dir="captures"):
+    """Capture image from webcam and save it"""
+    Path(output_dir).mkdir(exist_ok=True)
+
+    cap = cv2.VideoCapture(camera_index)
+    ret, frame = cap.read()
+    cap.release()
+
+    if not ret:
+        raise Exception("Failed to capture image from webcam")
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{output_dir}/webcam_{timestamp}.jpg"
+    cv2.imwrite(filename, frame)
+    print(f"📸 Captured: {filename}")
+    return filename
+
+def analyze_webcam_image(api_key, image_path, question="Describe what you see"):
+    """Analyze captured image using Newton model"""
+
+    client = ArchetypeAI(api_key)
+
+    # Lens configuration with model parameters
+    lens_config = {
+        "lens_name": f"webcam-analysis-{int(time.time())}",
+        "lens_config": {
+            "model_pipeline": [{
+                "processor_name": "lens_camera_processor",
+                "processor_config": {}
+            }],
+            "model_parameters": {
+                **MODEL_CONFIG,
+                "focus": question,
+                "camera_buffer_size": 1,
+                "min_replicas": 1,
+                "max_replicas": 1
+            }
+        }
+    }
+
+    lens_id = None
+    session_id = None
+
+    try:
+        # 1. Register lens
+        print("🔧 Setting up analysis...")
+        lens = client.lens.register(lens_config)
+        lens_id = lens['lens_id']
+
+        # 2. Create session
+        session = client.lens.sessions.create(lens_id)
+        session_id = session['session_id']
+
+        # 3. Wait for session ready
+        print("⏳ Initializing...")
+        for _ in range(30):
+            try:
+                status = client.lens.sessions.process_event(
+                    session_id, {"type": "session.status"}
+                )
+                if status.get('session_status') in ['3', 'LensSessionStatus.SESSION_STATUS_RUNNING']:
+                    break
+            except:
+                pass
+            time.sleep(0.5)
+
+        # 4. Initialize processor
+        client.lens.sessions.process_event(session_id, {
+            "type": "session.modify",
+            "event_data": {"camera_buffer_size": 1}
+        })
+
+        # 5. Prepare image
+        base64_img = base64_encode(image_path).replace("data:image/jpeg;base64,", "")
+
+        # 6. Query with image
+        print("🔍 Analyzing image...")
+        event = {
+            "type": "model.query",
+            "event_data": {
+                **MODEL_CONFIG,
+                "focus": question,
+                "data": [{
+                    "type": "base64_img",
+                    "base64_img": base64_img
+                }]
+            }
+        }
+
+        response = client.lens.sessions.process_event(session_id, event)
+
+        # 7. Extract result
+        if response.get('type') == 'model.query.response':
+            result = response.get('event_data', {}).get('response', '')
+            if isinstance(result, list):
+                result = result[0] if result else "No response"
+            print(f"\n💭 Answer: {result}")
+            return result
+        else:
+            print(f"Unexpected response: {json.dumps(response, indent=2)}")
+            return None
+
+    finally:
+        # Cleanup
+        if session_id:
+            try:
+                client.lens.sessions.destroy(session_id)
+            except:
+                pass
+        if lens_id:
+            try:
+                client.lens.delete(lens_id)
+            except:
+                pass
+
+def main():
+    # Get API key
+    api_key = os.environ.get("ARCHETYPE_API_KEY") or os.environ.get("ATAI_API_KEY")
+
+    if not api_key:
+        print("Error: Please set ARCHETYPE_API_KEY or ATAI_API_KEY environment variable")
+        sys.exit(1)
+
+    # Parse arguments
+    question = sys.argv[1] if len(sys.argv) > 1 else "Describe what you see"
+    camera_index = int(sys.argv[2]) if len(sys.argv) > 2 else 0
+
+    print(f"📷 Camera: {camera_index}")
+    print(f"❓ Question: {question}")
+    print("-" * 40)
+
+    try:
+        # Capture and analyze
+        image_path = capture_webcam_image(camera_index)
+        analyze_webcam_image(api_key, image_path, question)
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/files/skills/newton-camera-frame-analysis/scripts/captures/logs/api_responses_20260206_105610.json

@@ -0,0 +1,62 @@
+[
+  {
+    "timestamp": "2026-02-06T10:57:17.747432",
+    "frame_number": 1,
+    "response_time_seconds": 63.071,
+    "request": {
+      "type": "model.query",
+      "event_data": {
+        "model_version": "Newton::c2_3_7b_2508014e10af56",
+        "template_name": "image_qa_template_task",
+        "instruction": "Answer the following question about the image:",
+        "focus": "webcam_frame.py",
+        "max_new_tokens": 512,
+        "data": "[IMAGE DATA OMITTED]"
+      }
+    },
+    "response": {
+      "type": "model.query.response",
+      "message": "Response timed out for query"
+    }
+  },
+  {
+    "timestamp": "2026-02-06T10:57:26.154989",
+    "frame_number": 2,
+    "response_time_seconds": 1.968,
+    "request": {
+      "type": "model.query",
+      "event_data": {
+        "model_version": "Newton::c2_3_7b_2508014e10af56",
+        "template_name": "image_qa_template_task",
+        "instruction": "Answer the following question about the image:",
+        "focus": "webcam_frame.py",
+        "max_new_tokens": 512,
+        "data": "[IMAGE DATA OMITTED]"
+      }
+    },
+    "response": {
+      "type": "error",
+      "message": "Unknown session id: lsn-26020627e21501c0bdb5a9082b8cdd"
+    }
+  },
+  {
+    "timestamp": "2026-02-06T10:57:42.701721",
+    "frame_number": 3,
+    "response_time_seconds": 10.079,
+    "request": {
+      "type": "model.query",
+      "event_data": {
+        "model_version": "Newton::c2_3_7b_2508014e10af56",
+        "template_name": "image_qa_template_task",
+        "instruction": "Answer the following question about the image:",
+        "focus": "webcam_frame.py",
+        "max_new_tokens": 512,
+        "data": "[IMAGE DATA OMITTED]"
+      }
+    },
+    "response": {
+      "type": "error",
+      "message": "Unknown session id: lsn-26020627e21501c0bdb5a9082b8cdd"
+    }
+  }
+]

package/files/skills/newton-camera-frame-analysis/scripts/continuous_monitor.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Continuous monitoring script that captures and analyzes frames every 5 seconds."""
+
+import sys
+import os
+import time
+import signal
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+sys.path.append('skills/activity-monitor-frame-query/scripts')
+from webcam_analyze import capture_webcam_image, analyze_image
+
+class ContinuousMonitor:
+    def __init__(self, camera_index=0, output_dir="captures", interval=5, focus="Describe what you see"):
+        self.camera_index = camera_index
+        self.output_dir = output_dir
+        self.interval = interval
+        self.focus = focus
+        self.running = True
+        self.frame_count = 0
+
+        signal.signal(signal.SIGINT, self.signal_handler)
+        signal.signal(signal.SIGTERM, self.signal_handler)
+
+        Path(output_dir).mkdir(exist_ok=True)
+
+        self.api_key = os.environ.get("ATAI_API_KEY")
+        if not self.api_key:
+            raise RuntimeError("ATAI_API_KEY environment variable not set")
+
+    def signal_handler(self, signum, frame):
+        print("\n\nStopping continuous monitoring...")
+        self.running = False
+
+    def run(self):
+        """Run continuous monitoring loop."""
+        print(f"Starting continuous monitoring (Ctrl+C to stop)")
+        print(f"Camera: {self.camera_index}, Interval: {self.interval}s")
+        print(f"Output directory: {self.output_dir}")
+        print(f"Analysis focus: {self.focus}")
+        print("-" * 60)
+
+        while self.running:
+            try:
+                self.frame_count += 1
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                print(f"\n[Frame {self.frame_count}] {timestamp}")
+
+                image_path = capture_webcam_image(self.camera_index, self.output_dir)
+
+                analyze_image(self.api_key, image_path, self.focus)
+
+                if self.running:
+                    print(f"Waiting {self.interval} seconds...")
+                    time.sleep(self.interval)
+
+            except KeyboardInterrupt:
+                self.running = False
+                break
+            except Exception as e:
+                print(f"Error during capture/analysis: {e}")
+                if self.running:
+                    print(f"Retrying in {self.interval} seconds...")
+                    time.sleep(self.interval)
+
+        print(f"\nMonitoring complete. Captured {self.frame_count} frames.")
+        print(f"Images saved in: {self.output_dir}/")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Continuously capture and analyze webcam frames at regular intervals"
+    )
+    parser.add_argument(
+        "focus",
+        nargs="?",
+        default="Describe what you see and any changes from the previous frame",
+        help="Question or focus for analysis (default: describe changes)"
+    )
+    parser.add_argument(
+        "--camera", "-c",
+        type=int,
+        default=0,
+        help="Camera index (0 for built-in, 1+ for external)"
+    )
+    parser.add_argument(
+        "--interval", "-i",
+        type=float,
+        default=5.0,
+        help="Capture interval in seconds (default: 5)"
+    )
+    parser.add_argument(
+        "--output-dir", "-o",
+        default="captures",
+        help="Directory for saved captures (default: captures)"
+    )
+
+    args = parser.parse_args()
+
+    monitor = ContinuousMonitor(
+        camera_index=args.camera,
+        output_dir=args.output_dir,
+        interval=args.interval,
+        focus=args.focus
+    )
+
+    try:
+        monitor.run()
+    except Exception as e:
+        print(f"Fatal error: {e}")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

package/files/skills/newton-direct-query/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: newton-direct-query
+description: Simple direct query to Newton model using the /query API endpoint. Test API connectivity, run text queries, or post-process results from other lenses. No lens registration or session needed.
+argument-hint: [query]
+allowed-tools: Bash(python *), Read
+---
+
+# Newton Direct Query (Newton /query endpoint)
+
+Send a text query directly to Newton via `POST /v0.5/query`. No lens registration, no session, no SSE — just a simple request/response. Use for API testing, text Q&A, or post-processing results from other lenses.
+
+---
+
+## API Endpoint
+
+```
+POST https://api.u1.archetypeai.app/v0.5/query
+Authorization: Bearer {apiKey}
+Content-Type: application/json
+```
+
+## Request Body
+
+```json
+{
+  "query": "Your question or prompt here",
+  "system_prompt": "System-level instruction",
+  "instruction_prompt": "System-level instruction",
+  "file_ids": [],
+  "model": "Newton::c2_4_7b_251215a172f6d7",
+  "max_new_tokens": 1024,
+  "sanitize": false
+}
+```
+
+| Field | Type | Description |
+|---|---|---|
+| `query` | string | The user prompt / question (required) |
+| `system_prompt` | string | System-level instruction guiding the model |
+| `instruction_prompt` | string | Same as `system_prompt` — set both to the same value |
+| `file_ids` | string[] | File IDs to include as context (empty for text-only) |
+| `model` | string | Model ID (default: `Newton::c2_4_7b_251215a172f6d7`) |
+| `max_new_tokens` | number | Max response length (default: 1024) |
+| `sanitize` | boolean | Whether to sanitize input (default: false) |
+
+**IMPORTANT:** The body uses `model` (not `model_version`) and `system_prompt` + `instruction_prompt` (not `instruction`). Both `system_prompt` and `instruction_prompt` should be set to the same value.
+
+## Response Structure
+
+```json
+{
+  "response": {
+    "response": ["The model's answer text here"]
+  }
+}
+```
+
+Extract the text using this priority chain:
+1. `data.response.response[0]` (most common)
+2. `data.response[0]` (fallback)
+3. `data.response` as string (fallback)
+4. `data.text` (fallback)
+
+---
+
+## Web / JavaScript Implementation
+
+Uses a config object pattern with `systemPrompt` (optional, defaults to `''`) and `fileIds` (optional, defaults to `[]`). Timeout is 120s since Newton queries can be slow for long prompts.
+
+```javascript
+/**
+ * @param {Object} config
+ * @param {string} config.apiKey
+ * @param {string} config.query - The user prompt to send
+ * @param {string} [config.systemPrompt=''] - Optional system/instruction prompt
+ * @param {string[]} [config.fileIds=[]] - Optional file IDs to include as context
+ * @param {number} [config.maxNewTokens=1024]
+ * @returns {Promise<string>} The model's text response
+ */
+async function runDirectQuery(config) {
+  const { apiKey, query, systemPrompt = '', fileIds = [], maxNewTokens = 1024 } = config
+
+  const response = await fetch('https://api.u1.archetypeai.app/v0.5/query', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      query,
+      system_prompt: systemPrompt,
+      instruction_prompt: systemPrompt,
+      file_ids: fileIds,
+      model: 'Newton::c2_4_7b_251215a172f6d7',
+      max_new_tokens: maxNewTokens,
+      sanitize: false,
+    }),
+    signal: AbortSignal.timeout(120000),
+  })
+
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}))
+    throw new Error(`Query failed: ${response.status} - ${JSON.stringify(errorBody)}`)
+  }
+
+  const data = await response.json()
+
+  // Extract response text — nested response.response[0] is most common
+  if (data.response?.response && Array.isArray(data.response.response)) {
+    return data.response.response[0] || ''
+  }
+  if (data.response && Array.isArray(data.response)) {
+    return data.response[0] || ''
+  }
+  if (data.response && typeof data.response === 'string') {
+    return data.response
+  }
+  if (data.text) {
+    return data.text
+  }
+
+  return JSON.stringify(data)
+}
+
+// Usage
+const answer = await runDirectQuery({
+  apiKey,
+  query: 'What is the capital of France?',
+  systemPrompt: 'Answer the question concisely.',
+})
+console.log(answer) // "Paris"
+
+// With file context
+const summary = await runDirectQuery({
+  apiKey,
+  query: 'Summarize the sensor data patterns.',
+  systemPrompt: 'You are a sensor data analyst.',
+  fileIds: ['file-abc123'],
+})
+```
+
+---
+
+## Python Implementation
+
+```python
+import os
+import requests
+
+API_URL = "https://api.u1.archetypeai.app/v0.5/query"
+
+def query_newton(query: str, system_prompt: str, api_key: str, max_new_tokens: int = 1024) -> str:
+    """Send a direct text query to Newton."""
+    response = requests.post(
+        API_URL,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "query": query,
+            "system_prompt": system_prompt,
+            "instruction_prompt": system_prompt,
+            "file_ids": [],
+            "model": "Newton::c2_4_7b_251215a172f6d7",
+            "max_new_tokens": max_new_tokens,
+            "sanitize": False,
+        },
+        timeout=60,
+    )
+    response.raise_for_status()
+    data = response.json()
+
+    # Extract response text (multiple possible shapes)
+    resp = data.get("response")
+    if isinstance(resp, dict) and isinstance(resp.get("response"), list):
+        return resp["response"][0] or ""
+    if isinstance(resp, list):
+        return resp[0] or ""
+    if isinstance(resp, str):
+        return resp
+    if data.get("text"):
+        return data["text"]
+
+    return str(data)
+
+
+# Usage
+api_key = os.getenv("ATAI_API_KEY") or os.getenv("ARCHETYPE_API_KEY")
+answer = query_newton(
+    "What is the capital of France?",
+    "Answer the question concisely.",
+    api_key,
+)
+print(answer)  # "Paris"
+```
+
+---
+
+## Use Cases
+
+- **API connectivity testing**: Verify your API key works
+- **Quick text Q&A**: Get answers without lens/session setup
+- **Post-processing**: Send results from other lenses (activity monitor, machine state) to Newton for summarization or comparison
+- **Debugging**: Verify the `/query` endpoint behavior
+
+## Troubleshooting
+
+- **"Failed to fetch"**: Check the request body format — use `model` (not `model_version`), `system_prompt` + `instruction_prompt` (not `instruction`), and `query` (not `focus`)
+- **Empty response**: Check the response extraction chain — the text is typically in `data.response.response[0]`
+- **Authentication error**: Verify API key is correct and has the `Bearer ` prefix
+- **Timeout**: Newton queries can take 10-30s for long prompts; use a 60s timeout

package/files/skills/newton-direct-query/scripts/direct_query.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Simple direct query to Newton model using the /query API endpoint
+"""
+
+import os
+import sys
+import json
+
+# Install requests if not available
+try:
+    import requests
+except ImportError:
+    print("Installing requests library...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "requests"])
+    import requests
+
+
+def query_archetype_ai(
+    api_key: str,
+    system_prompt: str = "Answer the question",
+    user_prompt: str = "What's the capital of France?",
+    api_endpoint: str = "https://api.u1.archetypeai.app/v0.5"
+) -> dict:
+    """
+    Query ArchetypeAI Newton model
+
+    Args:
+        api_key: Your ArchetypeAI API key
+        system_prompt: The system instruction (default: "Answer the question")
+        user_prompt: The user query (default: "What's the capital of France?")
+        api_endpoint: API endpoint URL
+
+    Returns:
+        Dictionary with the API response
+    """
+
+    # Exact API URL
+    api_url = f"{api_endpoint}/query"
+
+    # Request payload
+    request_data = {
+        "query": user_prompt,
+        "system_prompt": system_prompt,
+        "instruction_prompt": system_prompt,
+        "file_ids": [],
+        "model": "Newton::c2_4_7b_251215a172f6d7",
+        "max_new_tokens": 1024,
+        "sanitize": False
+    }
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+
+    try:
+        response = requests.post(api_url, headers=headers, json=request_data, timeout=30)
+        response.raise_for_status()
+
+        data = response.json()
+
+        # Extract response text
+        response_text = ''
+        if data.get('response') and data['response'].get('response') and isinstance(data['response']['response'], list):
+            response_text = data['response']['response'][0] or ''
+        elif data.get('response') and isinstance(data.get('response'), list):
+            response_text = data['response'][0] or ''
+        elif data.get('response') and isinstance(data.get('response'), str):
+            response_text = data['response']
+        elif data.get('text'):
+            response_text = data['text']
+
+        return {
+            "success": True,
+            "response": response_text,
+            "full_response": data
+        }
+
+    except requests.exceptions.RequestException as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "response": None
+        }
+
+
+def main():
+    """Main function to run the query"""
+
+    # Get API key from environment
+    api_key = os.environ.get("ARCHETYPE_API_KEY") or os.environ.get("ATAI_API_KEY")
+
+    # Allow API key as first argument
+    if not api_key and len(sys.argv) > 1:
+        api_key = sys.argv[1]
+
+    if not api_key:
+        print("Error: Please provide API key either as:")
+        print("  1. Environment variable: export ARCHETYPE_API_KEY=your_key")
+        print("  2. Command line argument: python direct_query.py your_key")
+        sys.exit(1)
+
+    print("=" * 60)
+    print("ArchetypeAI Direct Query Test")
+    print("=" * 60)
+
+    system_prompt = "Answer the question"
+    user_prompt = "What's the capital of France?"
+
+    print(f"System Prompt: {system_prompt}")
+    print(f"User Prompt: {user_prompt}")
+    print("-" * 40)
+
+    result = query_archetype_ai(api_key, system_prompt, user_prompt)
+
+    if result["success"]:
+        print(f"Response: {result['response']}")
+        print("\n✓ API connection successful!")
+    else:
+        print(f"Error: {result['error']}")
+        print("\n✗ API connection failed!")
+
+    return 0 if result["success"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())