cosmon-agent-sdk 0.1.0__tar.gz

cosmon_agent_sdk-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.venv/

cosmon_agent_sdk-0.1.0/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to `cosmon-agent-sdk` are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project follows
+[Semantic Versioning](https://semver.org/) (while `0.x`, breaking changes may ride
+minor bumps — see the design doc §6).
+
+## [Unreleased]
+
+## [0.1.0] — Unreleased
+
+Initial release. The SDK is an [MCP](https://modelcontextprotocol.io) client for
+the local MCP server the Cosmon app exposes — the agent is the tool.
+
+### Added
+- `Client` / `AsyncClient` — discover the running app (via the descriptor; or
+  explicit `endpoint`/`token`), connect to its MCP server, and drive the agent.
+  Used as context managers; `AsyncClient` is native async, `Client` is a blocking
+  façade over it.
+- `client.run(prompt, agent=, attachments=)` returning a `Run` / `AsyncRun`.
+  Consume it either way: `.text()` runs to completion and returns the agent's
+  final answer, or iterate it (`for event in run` / `async for`) to stream typed
+  `ToolCall` / `TextChunk` events (fed by MCP progress notifications).
+- `client.discover()` → `DiscoverInfo` (login state, agents, model, runtime
+  readiness) from the `nexus://status` resource.
+- **Interactive** runs via `on_question` / `on_confirm` handlers, mapped onto MCP
+  elicitation (`Question` / `Confirmation`). Supplying handlers declares the
+  elicitation capability; omitting both runs the agent unattended (no `ask_user`;
+  confirms auto-resolved — approve safe, decline dangerous). Because elicitation
+  is answered out of band, `.text()` never stalls or raises mid-run for input.
+- Long client-side `timeout` (default 10 min) so multi-minute runs complete.
+- Typed error family (`CosmonError` and subclasses, incl. `CosmonRunError`).
+  `py.typed` shipped.
+- `cosmon` CLI: `doctor`, `run`, `ask` (headless; `--auto-approve`).
+
+[Unreleased]: https://github.com/Cosmon-Inc/cosmon
+[0.1.0]: https://github.com/Cosmon-Inc/cosmon

cosmon_agent_sdk-0.1.0/LICENSE

@@ -0,0 +1,31 @@
+Copyright (c) 2026 Cosmon, Inc. All rights reserved.
+
+NEXUS AGENT SDK — PROPRIETARY SOFTWARE LICENSE
+
+This software and associated documentation files (the "Software") are the
+proprietary and confidential property of Cosmon, Inc. ("Cosmon").
+
+1. License grant. Subject to your agreement to Cosmon's Terms of Service and any
+   applicable subscription or commercial agreement, Cosmon grants you a limited,
+   non-exclusive, non-transferable, revocable license to install and use the
+   Software solely to interface with the Cosmon Nexus application that you have
+   licensed and are authorized to use.
+
+2. Restrictions. You may not, except to the extent permitted by applicable law:
+   (a) copy, modify, or create derivative works of the Software; (b) reverse
+   engineer, decompile, or disassemble the Software; (c) redistribute, sublicense,
+   sell, rent, or lease the Software; or (d) remove or alter any proprietary
+   notices.
+
+3. Ownership. The Software is licensed, not sold. Cosmon retains all right, title,
+   and interest in and to the Software, including all intellectual property rights.
+
+4. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+5. Limitation of liability. IN NO EVENT SHALL COSMON BE LIABLE FOR ANY CLAIM,
+   DAMAGES, OR OTHER LIABILITY ARISING FROM OR IN CONNECTION WITH THE SOFTWARE OR
+   ITS USE.
+
+For licensing inquiries, contact legal@cosmon.com.

cosmon_agent_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: cosmon-agent-sdk
+Version: 0.1.0
+Summary: Program the Nexus agent in your installed Cosmon app — drive SolidWorks, Abaqus, COMSOL, Fluent and more.
+Project-URL: Homepage, https://cosmon.com
+Project-URL: Documentation, https://docs.cosmon.com/sdk/overview
+Project-URL: Repository, https://github.com/Cosmon-Inc/cosmon
+Author-email: "Cosmon, Inc." <support@cosmon.com>
+License: Copyright (c) 2026 Cosmon, Inc. All rights reserved.
+        
+        NEXUS AGENT SDK — PROPRIETARY SOFTWARE LICENSE
+        
+        This software and associated documentation files (the "Software") are the
+        proprietary and confidential property of Cosmon, Inc. ("Cosmon").
+        
+        1. License grant. Subject to your agreement to Cosmon's Terms of Service and any
+           applicable subscription or commercial agreement, Cosmon grants you a limited,
+           non-exclusive, non-transferable, revocable license to install and use the
+           Software solely to interface with the Cosmon Nexus application that you have
+           licensed and are authorized to use.
+        
+        2. Restrictions. You may not, except to the extent permitted by applicable law:
+           (a) copy, modify, or create derivative works of the Software; (b) reverse
+           engineer, decompile, or disassemble the Software; (c) redistribute, sublicense,
+           sell, rent, or lease the Software; or (d) remove or alter any proprietary
+           notices.
+        
+        3. Ownership. The Software is licensed, not sold. Cosmon retains all right, title,
+           and interest in and to the Software, including all intellectual property rights.
+        
+        4. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+           EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+           MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+        
+        5. Limitation of liability. IN NO EVENT SHALL COSMON BE LIABLE FOR ANY CLAIM,
+           DAMAGES, OR OTHER LIABILITY ARISING FROM OR IN CONNECTION WITH THE SOFTWARE OR
+           ITS USE.
+        
+        For licensing inquiries, contact legal@cosmon.com.
+License-File: LICENSE
+Keywords: agent,cad,cae,cosmon,mcp,nexus,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: anyio>=4
+Requires-Dist: httpx>=0.24
+Requires-Dist: mcp<2,>=1.28
+Requires-Dist: pydantic>=2
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Cosmon Agent SDK (Python)
+
+Program the **Nexus agent** in your installed, signed-in Cosmon app — drive
+SolidWorks, Abaqus, COMSOL, Fluent, Ansys Mechanical and more from your own
+Python. Your code brings the *caller*; the installed app brings the *capability*
+(your login, your credits, the CAD software on your machine). **Your code never
+holds a key.**
+
+Under the hood the SDK is a small [MCP](https://modelcontextprotocol.io) client:
+it discovers the running app, connects to the local MCP server it exposes, and
+drives the agent through one `run` tool.
+
+## Install
+
+```bash
+pip install cosmon-agent-sdk
+```
+
+Then: open Cosmon, sign in, and turn on **Settings → Developer access**.
+
+Check it's working:
+
+```bash
+cosmon doctor
+```
+
+## Quickstart
+
+`client.run()` returns a `Run`; get the agent's final answer with `.text()`:
+
+```python
+from cosmon_agent_sdk import Client
+
+with Client() as client:
+    answer = client.run("What's the max von Mises in bracket.sldprt?", agent="solidworks").text()
+    print(answer)
+```
+
+Or **iterate** the run to stream it — it yields typed `ToolCall` / `TextChunk`
+events (`.text()` and iterating are the two ways to consume a run; pick one):
+
+```python
+import sys
+from cosmon_agent_sdk import Client, TextChunk, ToolCall
+
+with Client() as client:
+    for event in client.run("Run a static study on bracket.sldprt", agent="solidworks"):
+        if isinstance(event, TextChunk):
+            print(event.text, end="", flush=True)          # answer, token by token
+        elif isinstance(event, ToolCall) and not event.finished:
+            print(f"[{event.summary}]", file=sys.stderr)    # tool steps
+```
+
+## Attended vs unattended
+
+Interactivity is set when you build the client, by whether you supply handlers:
+
+- **Unattended (default)** — no handlers. The agent is never offered `ask_user`
+  (it proceeds on its own) and confirmations are auto-resolved (approve safe,
+  **decline dangerous**). `.text()` just runs to completion. This is the headless
+  path; put any decisions the agent might otherwise ask about in the prompt.
+- **Interactive** — supply `on_question` and/or `on_confirm`. The app forwards the
+  agent's `ask_user` / `confirm_action` to your handlers (over MCP elicitation)
+  while `.text()` runs to completion. There's no event loop to drive — your
+  handlers are called as needed, so `.text()` never stalls waiting for an answer.
+
+```python
+from cosmon_agent_sdk import Client, Question, Confirmation
+
+def answer(question: Question) -> str:
+    return question.options[0] if question.options else "10mm seed size"
+
+def approve(confirmation: Confirmation) -> bool:
+    return True  # your policy here
+
+with Client(on_question=answer, on_confirm=approve) as client:
+    print(client.run("Mesh the model and submit the job", agent="abaqus").text())
+```
+
+## Long runs
+
+The agent can work for many minutes (mesh, solve, post-process). The client sets
+a generous default `timeout` (10 minutes) and you can raise it:
+
+```python
+with Client(timeout=1800) as client:   # 30 minutes
+    client.run("Run a mesh-convergence study on bracket.sldprt", agent="solidworks").text()
+```
+
+## Async
+
+`AsyncClient` is the async twin (for pipelines, FastAPI, etc.) — same surface,
+`await`ed:
+
+```python
+import asyncio
+from cosmon_agent_sdk import AsyncClient
+
+async def main() -> None:
+    async with AsyncClient() as client:
+        print(await client.run("what can you do?", agent="nexus").text())
+
+asyncio.run(main())
+```
+
+`Client`/`AsyncClient` and `Run`/`AsyncRun` are the sync/async pairs.
+
+## Command line
+
+```bash
+cosmon doctor                                  # check the connection, step by step
+cosmon run "mesh and solve" --agent abaqus                  # stream the work (steps to stderr)
+cosmon run "what can you do?" --agent nexus -q              # -q: print just the final answer
+```
+
+The CLI is headless (it can't answer `ask_user`); `--auto-approve` additionally
+approves confirmation requests, including dangerous ones.
+
+## Notes
+
+- **Discovery**: the app writes a `mcp-gateway.json` descriptor while Developer
+  access is on; the SDK reads it automatically. Override with the
+  `COSMON_SDK_DESCRIPTOR` environment variable.
+- **Errors**: connecting / starting a run can raise `CosmonConnectionError`,
+  `CosmonAuthError`, `CosmonTimeoutError`, `CosmonProtocolError`; a run that fails
+  while running raises `CosmonRunError` from `.text()`.
+- Docs: <https://docs.cosmon.com/>

cosmon_agent_sdk-0.1.0/README.md

@@ -0,0 +1,127 @@
+# Cosmon Agent SDK (Python)
+
+Program the **Nexus agent** in your installed, signed-in Cosmon app — drive
+SolidWorks, Abaqus, COMSOL, Fluent, Ansys Mechanical and more from your own
+Python. Your code brings the *caller*; the installed app brings the *capability*
+(your login, your credits, the CAD software on your machine). **Your code never
+holds a key.**
+
+Under the hood the SDK is a small [MCP](https://modelcontextprotocol.io) client:
+it discovers the running app, connects to the local MCP server it exposes, and
+drives the agent through one `run` tool.
+
+## Install
+
+```bash
+pip install cosmon-agent-sdk
+```
+
+Then: open Cosmon, sign in, and turn on **Settings → Developer access**.
+
+Check it's working:
+
+```bash
+cosmon doctor
+```
+
+## Quickstart
+
+`client.run()` returns a `Run`; get the agent's final answer with `.text()`:
+
+```python
+from cosmon_agent_sdk import Client
+
+with Client() as client:
+    answer = client.run("What's the max von Mises in bracket.sldprt?", agent="solidworks").text()
+    print(answer)
+```
+
+Or **iterate** the run to stream it — it yields typed `ToolCall` / `TextChunk`
+events (`.text()` and iterating are the two ways to consume a run; pick one):
+
+```python
+import sys
+from cosmon_agent_sdk import Client, TextChunk, ToolCall
+
+with Client() as client:
+    for event in client.run("Run a static study on bracket.sldprt", agent="solidworks"):
+        if isinstance(event, TextChunk):
+            print(event.text, end="", flush=True)          # answer, token by token
+        elif isinstance(event, ToolCall) and not event.finished:
+            print(f"[{event.summary}]", file=sys.stderr)    # tool steps
+```
+
+## Attended vs unattended
+
+Interactivity is set when you build the client, by whether you supply handlers:
+
+- **Unattended (default)** — no handlers. The agent is never offered `ask_user`
+  (it proceeds on its own) and confirmations are auto-resolved (approve safe,
+  **decline dangerous**). `.text()` just runs to completion. This is the headless
+  path; put any decisions the agent might otherwise ask about in the prompt.
+- **Interactive** — supply `on_question` and/or `on_confirm`. The app forwards the
+  agent's `ask_user` / `confirm_action` to your handlers (over MCP elicitation)
+  while `.text()` runs to completion. There's no event loop to drive — your
+  handlers are called as needed, so `.text()` never stalls waiting for an answer.
+
+```python
+from cosmon_agent_sdk import Client, Question, Confirmation
+
+def answer(question: Question) -> str:
+    return question.options[0] if question.options else "10mm seed size"
+
+def approve(confirmation: Confirmation) -> bool:
+    return True  # your policy here
+
+with Client(on_question=answer, on_confirm=approve) as client:
+    print(client.run("Mesh the model and submit the job", agent="abaqus").text())
+```
+
+## Long runs
+
+The agent can work for many minutes (mesh, solve, post-process). The client sets
+a generous default `timeout` (10 minutes) and you can raise it:
+
+```python
+with Client(timeout=1800) as client:   # 30 minutes
+    client.run("Run a mesh-convergence study on bracket.sldprt", agent="solidworks").text()
+```
+
+## Async
+
+`AsyncClient` is the async twin (for pipelines, FastAPI, etc.) — same surface,
+`await`ed:
+
+```python
+import asyncio
+from cosmon_agent_sdk import AsyncClient
+
+async def main() -> None:
+    async with AsyncClient() as client:
+        print(await client.run("what can you do?", agent="nexus").text())
+
+asyncio.run(main())
+```
+
+`Client`/`AsyncClient` and `Run`/`AsyncRun` are the sync/async pairs.
+
+## Command line
+
+```bash
+cosmon doctor                                  # check the connection, step by step
+cosmon run "mesh and solve" --agent abaqus                  # stream the work (steps to stderr)
+cosmon run "what can you do?" --agent nexus -q              # -q: print just the final answer
+```
+
+The CLI is headless (it can't answer `ask_user`); `--auto-approve` additionally
+approves confirmation requests, including dangerous ones.
+
+## Notes
+
+- **Discovery**: the app writes a `mcp-gateway.json` descriptor while Developer
+  access is on; the SDK reads it automatically. Override with the
+  `COSMON_SDK_DESCRIPTOR` environment variable.
+- **Errors**: connecting / starting a run can raise `CosmonConnectionError`,
+  `CosmonAuthError`, `CosmonTimeoutError`, `CosmonProtocolError`; a run that fails
+  while running raises `CosmonRunError` from `.text()`.
+- Docs: <https://docs.cosmon.com/>

cosmon_agent_sdk-0.1.0/examples/README.md

@@ -0,0 +1,35 @@
+# Examples
+
+Runnable examples for the Cosmon Agent SDK.
+
+## Prerequisites
+
+1. Install the SDK — `pip install cosmon-agent-sdk` (or `pip install -e .` from the repo root).
+2. Open Cosmon, **sign in**, and turn on **Settings → Developer access**.
+3. Check the connection: `cosmon doctor`.
+
+> **Dev builds:** the app's data dir is named `nexus`, not `Cosmon`, so the SDK's
+> default descriptor path won't match. Point it at the path `cosmon doctor` reports:
+>
+> ```bash
+> export COSMON_SDK_DESCRIPTOR="$HOME/Library/Application Support/nexus/mcp-gateway.json"
+> ```
+
+## The examples
+
+| File | What it shows |
+|---|---|
+| `quickstart.py` | The one-liner: `client.run(...).text()`. |
+| `streaming.py` | Stream the run — iterate typed `ToolCall` / `TextChunk` events. |
+| `structural_study.py` | Interactive run — answer the agent's questions and approve actions with `on_question` / `on_confirm`. |
+| `batch.py` | Unattended batch over many files (no handlers). |
+| `async_quickstart.py` | The async client (`AsyncClient`). |
+| `playground.py` | Interactive REPL — drive the agent from your terminal. |
+
+Run any of them:
+
+```bash
+python examples/quickstart.py
+python examples/playground.py solidworks
+python examples/batch.py beam1.sldprt beam2.sldprt
+```

cosmon_agent_sdk-0.1.0/examples/async_quickstart.py

@@ -0,0 +1,24 @@
+"""Async — drive the agent from an asyncio program (FastAPI, pipelines, etc.).
+Same surface as the sync client, awaited.
+
+    python examples/async_quickstart.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from cosmon_agent_sdk import AsyncClient
+
+
+async def main() -> None:
+    async with AsyncClient() as client:
+        answer = await client.run(
+            "In one sentence, who are you and what can you help me with?",
+            agent="nexus",
+        ).text()
+        print(answer)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

cosmon_agent_sdk-0.1.0/examples/attachments.py

@@ -0,0 +1,30 @@
+"""Hand files to a run — the agent reads them alongside the prompt.
+
+    python examples/attachments.py <path> [<path> ...]
+
+Relative paths are resolved against YOUR working directory (the SDK
+absolutizes them before sending — the app's tool server has its own cwd), and
+a missing file raises immediately instead of leaving the agent hunting for it.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from cosmon_agent_sdk import Client
+
+
+def main() -> None:
+    paths = sys.argv[1:]
+    if not paths:
+        raise SystemExit("usage: python examples/attachments.py <path> [<path> ...]")
+    with Client() as client:
+        client.run(
+            "describe the attached file(s) in a couple of sentences",
+            agent="nexus",
+            attachments=paths,
+        ).text(live=True)
+
+
+if __name__ == "__main__":
+    main()

cosmon_agent_sdk-0.1.0/examples/batch.py

@@ -0,0 +1,37 @@
+"""Run an analysis across many files, unattended.
+
+A client with no ``on_question`` / ``on_confirm`` handlers runs the agent
+unattended: it's never offered ``ask_user`` (it proceeds on its own) and
+confirmations are auto-resolved — approve safe actions, decline dangerous ones.
+So ``.text()`` just runs to completion. Put any decisions the agent might
+otherwise ask about directly in the prompt. ``timeout`` caps each run so one
+stuck file can't hang the whole batch.
+
+    python examples/batch.py beam1.sldprt beam2.sldprt
+"""
+
+from __future__ import annotations
+
+import sys
+
+from cosmon_agent_sdk import Client, CosmonError
+
+
+def main() -> None:
+    files = sys.argv[1:] or ["beam1.sldprt", "beam2.sldprt"]
+    with Client(timeout=600) as client:  # unattended; 10-minute ceiling per run
+        for path in files:
+            print(f"\n=== {path} ===")
+            try:
+                answer = client.run(
+                    f"Run a static structural study on {path} with a 10mm mesh seed "
+                    f"and report the peak von Mises stress.",
+                    agent="solidworks",
+                ).text()
+                print(answer)
+            except CosmonError as err:
+                print(f"  failed: {err}")
+
+
+if __name__ == "__main__":
+    main()

cosmon_agent_sdk-0.1.0/examples/elicitation.py

@@ -0,0 +1,48 @@
+"""Answer the agent's questions and approval gates from the terminal.
+
+    python examples/elicitation.py
+
+Passing handlers declares the elicitation capability: `on_question` answers
+`ask_user`, `on_confirm` answers confirmation gates — both out of band while
+`.text()` blocks, so expect the prompts to appear mid-call. (Passing only
+`on_confirm` runs question-free: the agent is never offered ask_user, but
+every approval gate still reaches the handler.) `live=True` prints the run
+live while you wait; the returned text stays the authoritative transcript.
+"""
+
+from __future__ import annotations
+
+from cosmon_agent_sdk import Client, Confirmation, Question
+
+DIM = "\x1b[2m"
+RESET = "\x1b[0m"
+
+def answer_question(question: Question) -> str:
+    # The app shows a countdown bar for this; a terminal can at least say it.
+    window = int(question.expires_in)
+    print(f"\n{DIM}[agent asks — ~{window}s before it proceeds without you]{RESET} {question.prompt}")
+    for index, option in enumerate(question.options, start=1):
+        print(f"   {index}) {option}")
+    # An empty answer is NOT a submission (a stray Enter would read as "no
+    # answer" and the agent would proceed on its own judgment) — re-prompt,
+    # exactly like the app disables its submit button on empty text.
+    while not (raw := input("answer> ").strip()):
+        pass
+    if question.options and raw.isdigit() and 1 <= int(raw) <= len(question.options):
+        return question.options[int(raw) - 1]
+    return raw
+
+def approve(confirmation: Confirmation) -> bool:
+    return input(f"\n[confirm] {confirmation.summary} [y/N]> ").strip().lower() in ("y", "yes")
+
+
+def main() -> None:
+    with Client(on_confirm=approve, on_question=answer_question) as client:
+        client.run(
+            "please ask me a question with multiple choices and then summarize the answer in one sentence",
+            agent="nexus",
+        ).text(live=True)
+
+
+if __name__ == "__main__":
+    main()

cosmon_agent_sdk-0.1.0/examples/handoff.py

@@ -0,0 +1,46 @@
+"""A run that spans a handoff chain, answered from the terminal.
+
+    python examples/handoff.py
+
+The entry agent hands off mid-run; `live=True` labels the stream with the
+agent in control (`[solidworks]`, `[comsol]`, …) so multi-agent runs stay
+attributable. Questions from ANY agent in the chain reach `on_question`;
+without `on_confirm`, approval gates auto-resolve (approve safe, decline
+dangerous), so the handoff itself proceeds unprompted.
+"""
+
+from __future__ import annotations
+
+from cosmon_agent_sdk import Client, Confirmation, Question
+
+DIM = "\x1b[2m"
+RESET = "\x1b[0m"
+
+def answer_question(question: Question) -> str:
+    print(f"\n{DIM}[agent asks]{RESET} {question.prompt}")
+    for index, option in enumerate(question.options, start=1):
+        print(f"   {index}) {option}")
+    raw = input("answer> ").strip()
+    if question.options and raw.isdigit() and 1 <= int(raw) <= len(question.options):
+        return question.options[int(raw) - 1]
+    return raw
+
+def approve(confirmation: Confirmation) -> bool:
+    return input(f"\n[confirm] {confirmation.summary} [y/N]> ").strip().lower() in ("y", "yes")
+
+
+def main() -> None:
+    with Client(
+        # on_confirm=approve, 
+        on_question=answer_question
+    ) as client:
+        client.run(
+            "please handoff to the comsol agent and ask me a multiple-choice "
+            "question through the ask question tool call, then summarize the "
+            "answer in one sentence",
+            agent="solidworks",
+        ).text(live=True)
+
+
+if __name__ == "__main__":
+    main()