cycls 0.0.2.64__tar.gz → 0.0.2.65__tar.gz

cycls-0.0.2.65/PKG-INFO

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: cycls
+Version: 0.0.2.65
+Summary: Distribute Intelligence
+Author: Mohammed J. AlRujayi
+Author-email: mj@cycls.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Programming Language :: Python :: 3.14
+Provides-Extra: modal
+Requires-Dist: cloudpickle (>=3.1.1,<4.0.0)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: fastapi (>=0.111.0,<0.112.0)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: modal (>=1.1.0,<2.0.0) ; extra == "modal"
+Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+<h3 align="center">
+Distribute Intelligence
+</h3>
+
+<h4 align="center">
+  <a href="https://cycls.com">Website</a> |
+  <a href="https://docs.cycls.com">Docs</a>
+</h4>
+
+<h4 align="center">
+  <a href="https://pypi.python.org/pypi/cycls"><img src="https://img.shields.io/pypi/v/cycls.svg?label=cycls+pypi&color=blueviolet" alt="cycls Python package on PyPi" /></a>
+  <a href="https://blog.cycls.com"><img src="https://img.shields.io/badge/newsletter-blueviolet.svg?logo=substack&label=cycls" alt="Cycls newsletter" /></a>
+  <a href="https://x.com/cyclsai">
+    <img src="https://img.shields.io/twitter/follow/CyclsAI" alt="Cycls Twitter" />
+  </a>
+</h4>
+
+---
+
+# Cycls
+
+The open-source SDK for distributing AI agents.
+
+## Distribute Intelligence
+
+AI capabilities shouldn't be locked in notebooks or trapped behind months of infrastructure work. Cycls turns your Python functions into production services - complete with APIs, interfaces, auth, and analytics. You focus on the intelligence. Cycls handles the distribution.
+
+Write a function. Deploy it as an API, a web interface, or both. Add authentication, analytics, and monetization with flags.
+
+```python
+import cycls
+
+agent = cycls.Agent(pip=["openai"])
+
+@agent("my-agent", auth=True, analytics=True)
+async def chat(context):
+    from openai import AsyncOpenAI
+    client = AsyncOpenAI()
+
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=context.messages,
+        stream=True
+    )
+
+    async for chunk in response:
+        if chunk.choices[0].delta.content:
+            yield chunk.choices[0].delta.content
+
+agent.deploy(prod=True)  # Live at https://my-agent.cycls.ai
+```
+
+## Installation
+
+```bash
+pip install cycls
+```
+
+Requires Docker.
+
+## What You Get
+
+- **Streaming API** - OpenAI-compatible `/chat/completions` endpoint
+- **Web Interface** - Chat UI served automatically
+- **Authentication** - `auth=True` enables JWT-based access control
+- **Analytics** - `analytics=True` tracks usage
+- **Monetization** - `tier="cycls_pass"` integrates with [Cycls Pass](https://cycls.ai) subscriptions
+- **Native UI Components** - Render thinking bubbles, tables, code blocks in responses
+
+## Deploying
+
+```python
+agent.deploy(prod=False)  # Development: localhost:8080
+agent.deploy(prod=True)   # Production: https://agent-name.cycls.ai
+```
+
+Get an API key at [cycls.com](https://cycls.com).
+
+## Native UI Components
+
+Yield structured objects for rich streaming responses:
+
+```python
+@agent()
+async def demo(context):
+    yield {"type": "thinking", "thinking": "Analyzing the request..."}
+    yield "Here's what I found:\n\n"
+
+    yield {"type": "table", "headers": ["Name", "Status"]}
+    yield {"type": "table", "row": ["Server 1", "Online"]}
+    yield {"type": "table", "row": ["Server 2", "Offline"]}
+
+    yield {"type": "code", "code": "result = analyze(data)", "language": "python"}
+    yield {"type": "callout", "callout": "Analysis complete!", "style": "success"}
+```
+
+| Component | Streaming |
+|-----------|-----------|
+| `{"type": "thinking", "thinking": "..."}` | Yes |
+| `{"type": "code", "code": "...", "language": "..."}` | Yes |
+| `{"type": "table", "headers": [...]}` | Yes |
+| `{"type": "table", "row": [...]}` | Yes |
+| `{"type": "status", "status": "..."}` | Yes |
+| `{"type": "callout", "callout": "...", "style": "..."}` | Yes |
+| `{"type": "image", "src": "..."}` | Yes |
+
+### Reasoning Models
+
+```python
+@agent()
+async def chat(context):
+    from openai import AsyncOpenAI
+    client = AsyncOpenAI()
+
+    stream = await client.responses.create(
+        model="o3-mini",
+        input=context.messages,
+        stream=True,
+        reasoning={"effort": "medium", "summary": "auto"},
+    )
+
+    async for event in stream:
+        if event.type == "response.reasoning_summary_text.delta":
+            yield {"type": "thinking", "thinking": event.delta}
+        elif event.type == "response.output_text.delta":
+            yield event.delta
+```
+
+## Context Object
+
+```python
+@agent()
+async def chat(context):
+    context.messages      # [{"role": "user", "content": "..."}]
+    context.messages.raw  # Full data including UI component parts
+    context.user          # User(id, email, name, plans) when auth=True
+```
+
+## API Endpoints
+
+| Endpoint | Format |
+|----------|--------|
+| `POST chat/cycls` | Cycls streaming protocol |
+| `POST chat/completions` | OpenAI-compatible |
+
+## Streaming Protocol
+
+Cycls streams structured components over SSE:
+
+```
+data: {"type": "thinking", "thinking": "Let me "}
+data: {"type": "thinking", "thinking": "analyze..."}
+data: {"type": "text", "text": "Here's the answer"}
+data: {"type": "callout", "callout": "Done!", "style": "success"}
+data: [DONE]
+```
+
+See [docs/streaming-protocol.md](docs/streaming-protocol.md) for frontend integration.
+
+## Declarative Infrastructure
+
+Define your entire runtime in Python:
+
+```python
+agent = cycls.Agent(
+    pip=["openai", "pandas", "numpy"],
+    apt=["ffmpeg", "libmagic1"],
+    run_commands=["curl -sSL https://example.com/setup.sh | bash"],
+    copy=["./utils.py", "./models/", "/absolute/path/to/config.json"],
+    copy_public=["./assets/logo.png", "./static/"],
+)
+```
+
+### `pip` - Python Packages
+
+Install any packages from PyPI. These are installed during the container build.
+
+```python
+pip=["openai", "pandas", "numpy", "transformers"]
+```
+
+### `apt` - System Packages
+
+Install system-level dependencies via apt-get. Need ffmpeg for audio processing? ImageMagick for images? Just declare it.
+
+```python
+apt=["ffmpeg", "imagemagick", "libpq-dev"]
+```
+
+### `run_commands` - Shell Commands
+
+Run arbitrary shell commands during the container build. Useful for custom setup scripts, downloading assets, or any build-time configuration.
+
+```python
+run_commands=[
+    "curl -sSL https://example.com/setup.sh | bash",
+    "chmod +x /app/scripts/*.sh"
+]
+```
+
+### `copy` - Bundle Files and Directories
+
+Include local files and directories in your container. Works with both relative and absolute paths. Copies files and entire directory trees.
+
+```python
+copy=[
+    "./utils.py",                    # Single file, relative path
+    "./models/",                     # Entire directory
+    "/home/user/configs/app.json",   # Absolute path
+]
+```
+
+Then import them in your function:
+
+```python
+@agent()
+async def chat(context):
+    from utils import helper_function  # Your bundled module
+    ...
+```
+
+### `copy_public` - Static Files
+
+Files and directories served at the `/public` endpoint. Perfect for images, downloads, or any static assets your agent needs to reference.
+
+```python
+copy_public=["./assets/logo.png", "./downloads/"]
+```
+
+Access them at `https://your-agent.cycls.ai/public/logo.png`.
+
+---
+
+### What You Get
+
+- **One file** - Code, dependencies, configuration, and infrastructure together
+- **Instant deploys** - Unchanged code deploys in seconds from cache
+- **No drift** - What you see is what runs. Always.
+- **Just works** - Closures, lambdas, dynamic imports - your function runs exactly as written
+
+No YAML. No Dockerfiles. No infrastructure repo. The code is the deployment.
+
+## License
+
+MIT
+

cycls-0.0.2.65/README.md

@@ -0,0 +1,245 @@
+<h3 align="center">
+Distribute Intelligence
+</h3>
+
+<h4 align="center">
+  <a href="https://cycls.com">Website</a> |
+  <a href="https://docs.cycls.com">Docs</a>
+</h4>
+
+<h4 align="center">
+  <a href="https://pypi.python.org/pypi/cycls"><img src="https://img.shields.io/pypi/v/cycls.svg?label=cycls+pypi&color=blueviolet" alt="cycls Python package on PyPi" /></a>
+  <a href="https://blog.cycls.com"><img src="https://img.shields.io/badge/newsletter-blueviolet.svg?logo=substack&label=cycls" alt="Cycls newsletter" /></a>
+  <a href="https://x.com/cyclsai">
+    <img src="https://img.shields.io/twitter/follow/CyclsAI" alt="Cycls Twitter" />
+  </a>
+</h4>
+
+---
+
+# Cycls
+
+The open-source SDK for distributing AI agents.
+
+## Distribute Intelligence
+
+AI capabilities shouldn't be locked in notebooks or trapped behind months of infrastructure work. Cycls turns your Python functions into production services - complete with APIs, interfaces, auth, and analytics. You focus on the intelligence. Cycls handles the distribution.
+
+Write a function. Deploy it as an API, a web interface, or both. Add authentication, analytics, and monetization with flags.
+
+```python
+import cycls
+
+agent = cycls.Agent(pip=["openai"])
+
+@agent("my-agent", auth=True, analytics=True)
+async def chat(context):
+    from openai import AsyncOpenAI
+    client = AsyncOpenAI()
+
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=context.messages,
+        stream=True
+    )
+
+    async for chunk in response:
+        if chunk.choices[0].delta.content:
+            yield chunk.choices[0].delta.content
+
+agent.deploy(prod=True)  # Live at https://my-agent.cycls.ai
+```
+
+## Installation
+
+```bash
+pip install cycls
+```
+
+Requires Docker.
+
+## What You Get
+
+- **Streaming API** - OpenAI-compatible `/chat/completions` endpoint
+- **Web Interface** - Chat UI served automatically
+- **Authentication** - `auth=True` enables JWT-based access control
+- **Analytics** - `analytics=True` tracks usage
+- **Monetization** - `tier="cycls_pass"` integrates with [Cycls Pass](https://cycls.ai) subscriptions
+- **Native UI Components** - Render thinking bubbles, tables, code blocks in responses
+
+## Deploying
+
+```python
+agent.deploy(prod=False)  # Development: localhost:8080
+agent.deploy(prod=True)   # Production: https://agent-name.cycls.ai
+```
+
+Get an API key at [cycls.com](https://cycls.com).
+
+## Native UI Components
+
+Yield structured objects for rich streaming responses:
+
+```python
+@agent()
+async def demo(context):
+    yield {"type": "thinking", "thinking": "Analyzing the request..."}
+    yield "Here's what I found:\n\n"
+
+    yield {"type": "table", "headers": ["Name", "Status"]}
+    yield {"type": "table", "row": ["Server 1", "Online"]}
+    yield {"type": "table", "row": ["Server 2", "Offline"]}
+
+    yield {"type": "code", "code": "result = analyze(data)", "language": "python"}
+    yield {"type": "callout", "callout": "Analysis complete!", "style": "success"}
+```
+
+| Component | Streaming |
+|-----------|-----------|
+| `{"type": "thinking", "thinking": "..."}` | Yes |
+| `{"type": "code", "code": "...", "language": "..."}` | Yes |
+| `{"type": "table", "headers": [...]}` | Yes |
+| `{"type": "table", "row": [...]}` | Yes |
+| `{"type": "status", "status": "..."}` | Yes |
+| `{"type": "callout", "callout": "...", "style": "..."}` | Yes |
+| `{"type": "image", "src": "..."}` | Yes |
+
+### Reasoning Models
+
+```python
+@agent()
+async def chat(context):
+    from openai import AsyncOpenAI
+    client = AsyncOpenAI()
+
+    stream = await client.responses.create(
+        model="o3-mini",
+        input=context.messages,
+        stream=True,
+        reasoning={"effort": "medium", "summary": "auto"},
+    )
+
+    async for event in stream:
+        if event.type == "response.reasoning_summary_text.delta":
+            yield {"type": "thinking", "thinking": event.delta}
+        elif event.type == "response.output_text.delta":
+            yield event.delta
+```
+
+## Context Object
+
+```python
+@agent()
+async def chat(context):
+    context.messages      # [{"role": "user", "content": "..."}]
+    context.messages.raw  # Full data including UI component parts
+    context.user          # User(id, email, name, plans) when auth=True
+```
+
+## API Endpoints
+
+| Endpoint | Format |
+|----------|--------|
+| `POST chat/cycls` | Cycls streaming protocol |
+| `POST chat/completions` | OpenAI-compatible |
+
+## Streaming Protocol
+
+Cycls streams structured components over SSE:
+
+```
+data: {"type": "thinking", "thinking": "Let me "}
+data: {"type": "thinking", "thinking": "analyze..."}
+data: {"type": "text", "text": "Here's the answer"}
+data: {"type": "callout", "callout": "Done!", "style": "success"}
+data: [DONE]
+```
+
+See [docs/streaming-protocol.md](docs/streaming-protocol.md) for frontend integration.
+
+## Declarative Infrastructure
+
+Define your entire runtime in Python:
+
+```python
+agent = cycls.Agent(
+    pip=["openai", "pandas", "numpy"],
+    apt=["ffmpeg", "libmagic1"],
+    run_commands=["curl -sSL https://example.com/setup.sh | bash"],
+    copy=["./utils.py", "./models/", "/absolute/path/to/config.json"],
+    copy_public=["./assets/logo.png", "./static/"],
+)
+```
+
+### `pip` - Python Packages
+
+Install any packages from PyPI. These are installed during the container build.
+
+```python
+pip=["openai", "pandas", "numpy", "transformers"]
+```
+
+### `apt` - System Packages
+
+Install system-level dependencies via apt-get. Need ffmpeg for audio processing? ImageMagick for images? Just declare it.
+
+```python
+apt=["ffmpeg", "imagemagick", "libpq-dev"]
+```
+
+### `run_commands` - Shell Commands
+
+Run arbitrary shell commands during the container build. Useful for custom setup scripts, downloading assets, or any build-time configuration.
+
+```python
+run_commands=[
+    "curl -sSL https://example.com/setup.sh | bash",
+    "chmod +x /app/scripts/*.sh"
+]
+```
+
+### `copy` - Bundle Files and Directories
+
+Include local files and directories in your container. Works with both relative and absolute paths. Copies files and entire directory trees.
+
+```python
+copy=[
+    "./utils.py",                    # Single file, relative path
+    "./models/",                     # Entire directory
+    "/home/user/configs/app.json",   # Absolute path
+]
+```
+
+Then import them in your function:
+
+```python
+@agent()
+async def chat(context):
+    from utils import helper_function  # Your bundled module
+    ...
+```
+
+### `copy_public` - Static Files
+
+Files and directories served at the `/public` endpoint. Perfect for images, downloads, or any static assets your agent needs to reference.
+
+```python
+copy_public=["./assets/logo.png", "./downloads/"]
+```
+
+Access them at `https://your-agent.cycls.ai/public/logo.png`.
+
+---
+
+### What You Get
+
+- **One file** - Code, dependencies, configuration, and infrastructure together
+- **Instant deploys** - Unchanged code deploys in seconds from cache
+- **No drift** - What you see is what runs. Always.
+- **Just works** - Closures, lambdas, dynamic imports - your function runs exactly as written
+
+No YAML. No Dockerfiles. No infrastructure repo. The code is the deployment.
+
+## License
+
+MIT

cycls-0.0.2.65/cycls/__init__.py

@@ -0,0 +1,2 @@
+from .sdk import Agent, function
+from .runtime import Runtime

{cycls-0.0.2.64 → cycls-0.0.2.65}/cycls/dev-theme/index.html

@@ -104,7 +104,7 @@
 
       // Native component renderers
       const components = {
-        text: (props) => marked.parse(props.content || '', { breaks: true }),
+        text: (props) => marked.parse(props.text || '', { breaks: true }),
 
         thinking: (props) => `
           <div class="thinking-bubble rounded-lg p-4 my-3 italic text-[var(--text-secondary)]">
@@ -114,7 +114,7 @@
               </svg>
               Thinking
             </div>
-            <div>${props.content}</div>
+            <div>${props.thinking}</div>
           </div>
         `,
 
@@ -141,8 +141,8 @@
 
         code: (props) => {
           const highlighted = props.language
-            ? hljs.highlight(props.content, { language: props.language }).value
-            : hljs.highlightAuto(props.content).value;
+            ? hljs.highlight(props.code, { language: props.language }).value
+            : hljs.highlightAuto(props.code).value;
           return `
             <div class="my-3 rounded-lg overflow-hidden border border-[var(--border-color)]">
               <div class="bg-[var(--bg-secondary)] px-4 py-2 text-xs text-[var(--text-secondary)] flex justify-between items-center">
@@ -155,9 +155,9 @@
         },
 
         callout: (props) => `
-          <div class="callout-${props.type || 'info'} border-l-4 rounded-r-lg p-4 my-3">
+          <div class="callout-${props.style || 'info'} border-l-4 rounded-r-lg p-4 my-3">
             ${props.title ? `<div class="font-semibold mb-1">${props.title}</div>` : ''}
-            <div class="text-sm">${props.content}</div>
+            <div class="text-sm">${props.callout}</div>
           </div>
         `,
 
@@ -204,7 +204,7 @@
         } else {
           let html = '';
           for (const part of msg.parts || [])
-            html += components[part.name]?.(part) || '';
+            html += components[part.type]?.(part) || '';
           wrapper.innerHTML = `<div class="prose prose-invert max-w-none">${html}</div>`;
         }
         return wrapper;
@@ -238,24 +238,6 @@
         let assistantMsg = messages[messages.length - 1];
         let currentPart = null;
 
-        const decode = {
-          '+': ([, name, props]) => {
-            currentPart = {name, ...props};
-            if (props.headers) currentPart.rows = [];
-            assistantMsg.parts.push(currentPart);
-          },
-          '~': ([, props]) => {
-            if (!currentPart) return;
-            for (const [k, v] of Object.entries(props)) {
-              if (k === 'content') currentPart.content = (currentPart.content || '') + v;
-              else if (k === 'row') currentPart.rows.push(v);
-              else currentPart[k] = v;
-            }
-          },
-          '-': () => { currentPart = null; },
-          '=': ([, props]) => { assistantMsg.parts.push(props); }
-        };
-
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
@@ -270,8 +252,19 @@
             if (data === '[DONE]') continue;
 
             try {
-              const msg = JSON.parse(data);
-              decode[msg[0]]?.(msg);
+              const item = JSON.parse(data);
+              const type = item.type;
+
+              // Same type as current? Append content
+              if (currentPart && currentPart.type === type) {
+                if (item.row) currentPart.rows.push(item.row);
+                else if (item[type]) currentPart[type] = (currentPart[type] || '') + item[type];
+              } else {
+                // New component
+                currentPart = { ...item };
+                if (item.headers) currentPart.rows = [];
+                assistantMsg.parts.push(currentPart);
+              }
               render();
             } catch (e) {
               console.error('Parse error:', e, data);
@@ -279,7 +272,7 @@
           }
         }
         assistantMsg.parts = assistantMsg.parts.filter(p =>
-          p.name !== 'text' || p.content?.trim()
+          p.type !== 'text' || p.text?.trim()
         );
         render();
         console.log(messages);

{cycls-0.0.2.64 → cycls-0.0.2.65}/cycls/web.py

@@ -15,36 +15,18 @@ async def openai_encoder(stream):
             if msg: yield f"data: {json.dumps({'choices': [{'delta': {'content': msg}}]})}\n\n"
     yield "data: [DONE]\n\n"
 
-class Encoder:
-    def __init__(self): self.cur = None
-    def sse(self, d): return f"data: {json.dumps(d)}\n\n"
-    def close(self):
-        if self.cur: self.cur = None; return self.sse(["-"])
-
-    def process(self, item):
-        if not item: return
-        if not isinstance(item, dict): item = {"name": "text", "content": item}
-        n, done = item.get("name"), item.get("_complete")
-        p = {k: v for k, v in item.items() if k not in ("name", "_complete")}
-        if done:
-            if c := self.close(): yield c
-            yield self.sse(["=", {"name": n, **p}])
-        elif n != self.cur:
-            if c := self.close(): yield c
-            self.cur = n
-            yield self.sse(["+", n, p])
-        else:
-            yield self.sse(["~", p])
+def sse(item):
+    if not item: return None
+    if not isinstance(item, dict): item = {"type": "text", "text": item}
+    return f"data: {json.dumps(item)}\n\n"
 
 async def encoder(stream):
-    enc = Encoder()
     if inspect.isasyncgen(stream):
         async for item in stream:
-            for msg in enc.process(item): yield msg
+            if msg := sse(item): yield msg
     else:
         for item in stream:
-            for msg in enc.process(item): yield msg
-    if close := enc.close(): yield close
+            if msg := sse(item): yield msg
     yield "data: [DONE]\n\n"
 
 class Messages(list):
@@ -54,7 +36,7 @@ class Messages(list):
         text_messages = []
         for m in raw_messages:
             text_content = "".join(
-                p.get("content", "") for p in m.get("parts", []) if p.get("name") == "text"
+                p.get("text", "") for p in m.get("parts", []) if p.get("type") == "text"
             )
             text_messages.append({
                 "role": m.get("role"),

{cycls-0.0.2.64 → cycls-0.0.2.65}/pyproject.toml

@@ -1,10 +1,10 @@
 [tool.poetry]
 name = "cycls"
-version = "0.0.2.64"
+version = "0.0.2.65"
 
 packages = [{ include = "cycls" }]
 include = ["cycls/theme/**/*"]
-description = "Cycls SDK"
+description = "Distribute Intelligence"
 authors = ["Mohammed J. AlRujayi <mj@cycls.com>"]
 readme = "README.md"
 

cycls-0.0.2.64/PKG-INFO

@@ -1,141 +0,0 @@
-Metadata-Version: 2.4
-Name: cycls
-Version: 0.0.2.64
-Summary: Cycls SDK
-Author: Mohammed J. AlRujayi
-Author-email: mj@cycls.com
-Requires-Python: >=3.9,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-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: Programming Language :: Python :: 3.14
-Provides-Extra: modal
-Requires-Dist: cloudpickle (>=3.1.1,<4.0.0)
-Requires-Dist: docker (>=7.1.0,<8.0.0)
-Requires-Dist: fastapi (>=0.111.0,<0.112.0)
-Requires-Dist: httpx (>=0.27.0,<0.28.0)
-Requires-Dist: modal (>=1.1.0,<2.0.0) ; extra == "modal"
-Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
-Description-Content-Type: text/markdown
-
-<h3 align="center">
-The Distribution SDK for AI Agents.
-</h3>
-
-<h4 align="center">
-  <a href="https://cycls.com">Website</a> |
-  <a href="https://docs.cycls.com">Docs</a>
-</h4>
-
-<h4 align="center">
-  <a href="https://pypi.python.org/pypi/cycls"><img src="https://img.shields.io/pypi/v/cycls.svg?label=cycls+pypi&color=blueviolet" alt="cycls Python package on PyPi" /></a>
-  <a href="https://blog.cycls.com"><img src="https://img.shields.io/badge/newsletter-blueviolet.svg?logo=substack&label=cycls" alt="Cycls newsletter" /></a>
-  <a href="https://x.com/cyclsai">
-    <img src="https://img.shields.io/twitter/follow/CyclsAI" alt="Cycls Twitter" />
-  </a>
-</h4>
-
-
-# Cycls 🚲
-
-`cycls` is an open-source SDK for building and publishing AI agents. With a single decorator and one command, you can deploy your code as a web application complete with a front-end UI and an OpenAI-compatible API endpoint.
-
-## Key Features
-
-* ✨ **Zero-Config Deployment:** No YAML or Dockerfiles. `cycls` infers your dependencies, and APIs directly from your Python code.
-* 🚀 **One-Command Push to Cloud:** Go from local code to a globally scalable, serverless application with a single `agent.deploy()`.
-* 💻 **Instant Local Testing:** Run `agent.local()` to spin up a local server with hot-reloading for rapid iteration and debugging.
-* 🤖 **OpenAI-Compatible API:** Automatically serves a streaming `/chat/completions` endpoint.
-* 🌐 **Automatic Web UI:** Get a clean, interactive front-end for your agent out of the box, with no front-end code required.
-* 🔐 **Built-in Authentication:** Secure your agent for production with a simple `auth=True` flag that enables JWT-based authentication.
-* 📦 **Declarative Dependencies:** Define all your `pip`, `apt`, or local file dependencies directly in Python.
-
-
-## Installation
-
-```bash
-pip install cycls
-```
-
-**Note:** You must have [Docker](https://www.docker.com/get-started) installed and running on your machine.
-
-## How to Use
-### 1. Local Development: "Hello, World!"
-
-Create a file main.py. This simple example creates an agent that streams back the message "hi".
-
-```py
-import cycls
-
-# Initialize the agent
-agent = cycls.Agent()
-
-# Decorate your function to register it as an agent
-@agent()
-async def hello(context):
-    yield "Hello, World!"
-
-agent.deploy(prod=False)
-```
-
-Run it from your terminal:
-
-```bash
-python main.py
-```
-This will start a local server. Open your browser to http://localhost:8080 to interact with your agent.
-
-### 2. Cloud Deployment: An OpenAI-Powered Agent
-This example creates a more advanced agent that calls the OpenAI API. It will be deployed to the cloud with authentication enabled.
-
-```py
-import cycls
-
-# Initialize the agent with dependencies and API keys
-agent = cycls.Agent(
-    pip=["openai"],
-    key="YOUR_CYCLS_KEY" # Get yours from https://cycls.com
-)
-
-# A helper function to call the LLM
-async def llm(messages):
-    # Import inside the function: 'openai' is needed at runtime in the container.
-    import openai
-    client = openai.AsyncOpenAI(api_key="YOUR_OPENAI_API_KEY")
-    model = "gpt-4o"
-    response = await client.chat.completions.create(
-        model=model,
-        messages=messages,
-        temperature=1.0,
-        stream=True
-    )
-    # Yield the content from the streaming response
-    async def event_stream():
-        async for chunk in response:
-            content = chunk.choices[0].delta.content
-            if content:
-                yield content
-    return event_stream()
-
-# Register the function as an agent named "cake" and enable auth
-@agent("cake", auth=True)
-async def cake_agent(context):
-    # The context object contains the message history
-    return await llm(context.messages)
-
-# Deploy the agent to the cloud
-agent.deploy(prod=True)
-```
-
-Run the deployment command from your terminal:
-
-```bash
-python main.py
-```
-After a few moments, your agent will be live and accessible at a public URL like https://cake.cycls.ai.
-
-### License
-This project is licensed under the MIT License.

cycls-0.0.2.64/README.md

@@ -1,118 +0,0 @@
-<h3 align="center">
-The Distribution SDK for AI Agents.
-</h3>
-
-<h4 align="center">
-  <a href="https://cycls.com">Website</a> |
-  <a href="https://docs.cycls.com">Docs</a>
-</h4>
-
-<h4 align="center">
-  <a href="https://pypi.python.org/pypi/cycls"><img src="https://img.shields.io/pypi/v/cycls.svg?label=cycls+pypi&color=blueviolet" alt="cycls Python package on PyPi" /></a>
-  <a href="https://blog.cycls.com"><img src="https://img.shields.io/badge/newsletter-blueviolet.svg?logo=substack&label=cycls" alt="Cycls newsletter" /></a>
-  <a href="https://x.com/cyclsai">
-    <img src="https://img.shields.io/twitter/follow/CyclsAI" alt="Cycls Twitter" />
-  </a>
-</h4>
-
-
-# Cycls 🚲
-
-`cycls` is an open-source SDK for building and publishing AI agents. With a single decorator and one command, you can deploy your code as a web application complete with a front-end UI and an OpenAI-compatible API endpoint.
-
-## Key Features
-
-* ✨ **Zero-Config Deployment:** No YAML or Dockerfiles. `cycls` infers your dependencies, and APIs directly from your Python code.
-* 🚀 **One-Command Push to Cloud:** Go from local code to a globally scalable, serverless application with a single `agent.deploy()`.
-* 💻 **Instant Local Testing:** Run `agent.local()` to spin up a local server with hot-reloading for rapid iteration and debugging.
-* 🤖 **OpenAI-Compatible API:** Automatically serves a streaming `/chat/completions` endpoint.
-* 🌐 **Automatic Web UI:** Get a clean, interactive front-end for your agent out of the box, with no front-end code required.
-* 🔐 **Built-in Authentication:** Secure your agent for production with a simple `auth=True` flag that enables JWT-based authentication.
-* 📦 **Declarative Dependencies:** Define all your `pip`, `apt`, or local file dependencies directly in Python.
-
-
-## Installation
-
-```bash
-pip install cycls
-```
-
-**Note:** You must have [Docker](https://www.docker.com/get-started) installed and running on your machine.
-
-## How to Use
-### 1. Local Development: "Hello, World!"
-
-Create a file main.py. This simple example creates an agent that streams back the message "hi".
-
-```py
-import cycls
-
-# Initialize the agent
-agent = cycls.Agent()
-
-# Decorate your function to register it as an agent
-@agent()
-async def hello(context):
-    yield "Hello, World!"
-
-agent.deploy(prod=False)
-```
-
-Run it from your terminal:
-
-```bash
-python main.py
-```
-This will start a local server. Open your browser to http://localhost:8080 to interact with your agent.
-
-### 2. Cloud Deployment: An OpenAI-Powered Agent
-This example creates a more advanced agent that calls the OpenAI API. It will be deployed to the cloud with authentication enabled.
-
-```py
-import cycls
-
-# Initialize the agent with dependencies and API keys
-agent = cycls.Agent(
-    pip=["openai"],
-    key="YOUR_CYCLS_KEY" # Get yours from https://cycls.com
-)
-
-# A helper function to call the LLM
-async def llm(messages):
-    # Import inside the function: 'openai' is needed at runtime in the container.
-    import openai
-    client = openai.AsyncOpenAI(api_key="YOUR_OPENAI_API_KEY")
-    model = "gpt-4o"
-    response = await client.chat.completions.create(
-        model=model,
-        messages=messages,
-        temperature=1.0,
-        stream=True
-    )
-    # Yield the content from the streaming response
-    async def event_stream():
-        async for chunk in response:
-            content = chunk.choices[0].delta.content
-            if content:
-                yield content
-    return event_stream()
-
-# Register the function as an agent named "cake" and enable auth
-@agent("cake", auth=True)
-async def cake_agent(context):
-    # The context object contains the message history
-    return await llm(context.messages)
-
-# Deploy the agent to the cloud
-agent.deploy(prod=True)
-```
-
-Run the deployment command from your terminal:
-
-```bash
-python main.py
-```
-After a few moments, your agent will be live and accessible at a public URL like https://cake.cycls.ai.
-
-### License
-This project is licensed under the MIT License.

cycls-0.0.2.64/cycls/__init__.py

@@ -1,3 +0,0 @@
-from .sdk import Agent, function
-from .runtime import Runtime
-from . import ui as UI

cycls-0.0.2.64/cycls/ui.py

@@ -1,6 +0,0 @@
-thinking = lambda content: {"name": "thinking", "content": content}
-status = lambda content: {"name": "status", "content": content}
-code = lambda content, language=None: {"name": "code", "content": content, "language": language}
-table = lambda headers=None, row=None: {"name": "table", "headers": headers} if headers else {"name": "table", "row": row} if row else None
-callout = lambda content, type="info", title=None: {"name": "callout", "content": content, "type": type, "title": title, "_complete": True}
-image = lambda src, alt=None, caption=None: {"name": "image", "src": src, "alt": alt, "caption": caption, "_complete": True}