cycls 0.0.2.64__tar.gz → 0.0.2.66__tar.gz

cycls-0.0.2.66/PKG-INFO

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: cycls
+Version: 0.0.2.66
+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.66/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.66/cycls/__init__.py

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

cycls-0.0.2.66/cycls/auth.py

@@ -0,0 +1,4 @@
+JWKS_PROD = "https://clerk.cycls.ai/.well-known/jwks.json"
+JWKS_TEST = "https://select-sloth-58.clerk.accounts.dev/.well-known/jwks.json"
+PK_LIVE = "pk_live_Y2xlcmsuY3ljbHMuYWkk"
+PK_TEST = "pk_test_c2VsZWN0LXNsb3RoLTU4LmNsZXJrLmFjY291bnRzLmRldiQ"

{cycls-0.0.2.64 → cycls-0.0.2.66}/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.66}/cycls/sdk.py

@@ -1,11 +1,25 @@
 import json, time, modal, inspect, uvicorn
 from .runtime import Runtime
 from modal.runner import run_app
-from .web import web
+from .web import web, Config
+from .auth import PK_LIVE, PK_TEST, JWKS_PROD, JWKS_TEST
 import importlib.resources
+from pydantic import BaseModel
+from typing import Callable
 
 CYCLS_PATH = importlib.resources.files('cycls')
 
+class RegisteredAgent(BaseModel):
+    func: Callable
+    name: str
+    domain: str
+    config: Config
+
+def set_prod(config: Config, prod: bool):
+    config.prod = prod
+    config.pk = PK_LIVE if prod else PK_TEST
+    config.jwks = JWKS_PROD if prod else JWKS_TEST
+
 themes = {
     "default": CYCLS_PATH.joinpath('default-theme'),
     "dev": CYCLS_PATH.joinpath('dev-theme'),
@@ -43,13 +57,21 @@ class Agent:
             auth=True
             analytics=True
         def decorator(f):
-            self.registered_functions.append({
-                "func": f,
-                "config": ["theme", False, self.org, self.api_token, header, intro, title, auth, tier, analytics],
-                # "name": name,
-                "name": name or (f.__name__).replace('_', '-'),
-                "domain": domain or f"{name}.cycls.ai",
-            })
+            agent_name = name or f.__name__.replace('_', '-')
+            self.registered_functions.append(RegisteredAgent(
+                func=f,
+                name=agent_name,
+                domain=domain or f"{agent_name}.cycls.ai",
+                config=Config(
+                    header=header,
+                    intro=intro,
+                    title=title,
+                    auth=auth,
+                    tier=tier,
+                    analytics=analytics,
+                    org=self.org,
+                ),
+            ))
             return f
         return decorator
 
@@ -57,13 +79,14 @@ class Agent:
         if not self.registered_functions:
             print("Error: No @agent decorated function found.")
             return
-        
-        i = self.registered_functions[0]
+
+        agent = self.registered_functions[0]
         if len(self.registered_functions) > 1:
-            print(f"⚠️  Warning: Multiple agents found. Running '{i['name']}'.")
+            print(f"⚠️  Warning: Multiple agents found. Running '{agent.name}'.")
         print(f"🚀 Starting local server at localhost:{port}")
-        i["config"][0] = self.theme
-        uvicorn.run(web(i["func"], *i["config"]), host="0.0.0.0", port=port)
+        agent.config.public_path = self.theme
+        set_prod(agent.config, False)
+        uvicorn.run(web(agent.func, agent.config), host="0.0.0.0", port=port)
         return
 
     def deploy(self, prod=False, port=8080):
@@ -74,27 +97,29 @@ class Agent:
             print("🛑  Error: Please add your Cycls API key")
             return
 
-        i = self.registered_functions[0]
+        agent = self.registered_functions[0]
         if len(self.registered_functions) > 1:
-            print(f"⚠️  Warning: Multiple agents found. Running '{i['name']}'.")
+            print(f"⚠️  Warning: Multiple agents found. Running '{agent.name}'.")
 
-        # i["config"][1] = False
-        i["config"][1] = prod
+        set_prod(agent.config, prod)
+        func = agent.func
+        name = agent.name
+        config_dict = agent.config.model_dump()
 
-        copy={str(self.theme):"theme", str(CYCLS_PATH)+"/web.py":"web.py"}
-        copy.update({i:i for i in self.copy})
-        copy.update({i:f"public/{i}" for i in self.copy_public})
+        files = {str(self.theme): "theme", str(CYCLS_PATH)+"/web.py": "web.py"}
+        files.update({f: f for f in self.copy})
+        files.update({f: f"public/{f}" for f in self.copy_public})
 
         new = Runtime(
-            func=lambda port: __import__("web").serve(i["func"], i["config"], i["name"], port),
-            name=i["name"],
+            func=lambda port: __import__("web").serve(func, config_dict, name, port),
+            name=name,
             apt_packages=self.apt,
             pip_packages=["fastapi[standard]", "pyjwt", "cryptography", "uvicorn", *self.pip],
-            copy=copy,
+            copy=files,
             base_url=self.base_url,
             api_key=self.key
         )
-        new.deploy(port=port) if prod else new.run(port=port) 
+        new.deploy(port=port) if prod else new.run(port=port)
         return
         
     def modal(self, prod=False):
@@ -117,22 +142,26 @@ class Agent:
             print("Error: No @agent decorated function found.")
             return
 
-        for i in self.registered_functions:
-            i["config"][1] = True if prod else False
-            self.app.function(serialized=True, name=i["name"])(
-                modal.asgi_app(label=i["name"], custom_domains=[i["domain"]])
-                (lambda: __import__("web").web(i["func"], *i["config"]))
+        for agent in self.registered_functions:
+            set_prod(agent.config, prod)
+            func = agent.func
+            name = agent.name
+            domain = agent.domain
+            config_dict = agent.config.model_dump()
+            self.app.function(serialized=True, name=name)(
+                modal.asgi_app(label=name, custom_domains=[domain])
+                (lambda: __import__("web").web(func, config_dict))
             )
         if prod:
-            for i in self.registered_functions:
-                print(f"✅ Deployed to ⇒ https://{i['domain']}")
-            self.app.deploy(client=self.client, name=self.registered_functions[0]["name"])
+            for agent in self.registered_functions:
+                print(f"✅ Deployed to ⇒ https://{agent.domain}")
+            self.app.deploy(client=self.client, name=self.registered_functions[0].name)
             return
         else:
             with modal.enable_output():
                 run_app(app=self.app, client=self.client)
                 print(" Modal development server is running. Press Ctrl+C to stop.")
-                with modal.enable_output(), run_app(app=self.app, client=self.client): 
+                with modal.enable_output(), run_app(app=self.app, client=self.client):
                     while True: time.sleep(10)
 
 # docker system prune -af

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

@@ -1,10 +1,20 @@
 import json, inspect
 from pathlib import Path
-
-JWKS_PROD = "https://clerk.cycls.ai/.well-known/jwks.json"
-PK_LIVE = "pk_live_Y2xlcmsuY3ljbHMuYWkk"
-JWKS_TEST = "https://select-sloth-58.clerk.accounts.dev/.well-known/jwks.json"
-PK_TEST = "pk_test_c2VsZWN0LXNsb3RoLTU4LmNsZXJrLmFjY291bnRzLmRldiQ"
+from pydantic import BaseModel
+from typing import Optional
+
+class Config(BaseModel):
+    public_path: str = "theme"
+    header: str = ""
+    intro: str = ""
+    title: str = ""
+    prod: bool = False
+    auth: bool = False
+    tier: str = "free"
+    analytics: bool = False
+    org: Optional[str] = None
+    pk: str = ""
+    jwks: str = ""
 
 async def openai_encoder(stream):
     if inspect.isasyncgen(stream):
@@ -15,36 +25,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 +46,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"),
@@ -66,17 +58,20 @@ class Messages(list):
     def raw(self):
         return self._raw
 
-def web(func, public_path="", prod=False, org=None, api_token=None, header="", intro="", title="", auth=False, tier="", analytics=False): # API auth
+def web(func, config):
     from fastapi import FastAPI, Request, HTTPException, status, Depends
-    from fastapi.responses import StreamingResponse , HTMLResponse
+    from fastapi.responses import StreamingResponse
     from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
     import jwt
     from jwt import PyJWKClient
-    from pydantic import BaseModel, EmailStr
+    from pydantic import EmailStr
     from typing import List, Optional, Any
     from fastapi.staticfiles import StaticFiles
 
-    jwks = PyJWKClient(JWKS_PROD if prod else JWKS_TEST)
+    if isinstance(config, dict):
+        config = Config(**config)
+
+    jwks = PyJWKClient(config.jwks)
 
     class User(BaseModel):
         id: str
@@ -85,18 +80,6 @@ def web(func, public_path="", prod=False, org=None, api_token=None, header="", i
         org: Optional[str] = None
         plans: List[str] = []
 
-    class Metadata(BaseModel):
-        header: str
-        intro: str
-        title: str
-        prod: bool
-        auth: bool
-        tier: str
-        analytics: bool
-        org: Optional[str]
-        pk_live: str
-        pk_test: str
-
     class Context(BaseModel):
         messages: Any
         user: Optional[User] = None
@@ -117,7 +100,7 @@ def web(func, public_path="", prod=False, org=None, api_token=None, header="", i
     @app.post("/")
     @app.post("/chat/cycls")
     @app.post("/chat/completions")
-    async def back(request: Request, jwt: Optional[dict] = Depends(validate) if auth else None):
+    async def back(request: Request, jwt: Optional[dict] = Depends(validate) if config.auth else None):
         data = await request.json()
         messages = data.get("messages")
         user_data = jwt.get("user") if jwt else None
@@ -129,29 +112,20 @@ def web(func, public_path="", prod=False, org=None, api_token=None, header="", i
             stream = encoder(stream)
         return StreamingResponse(stream, media_type="text/event-stream")
 
-    @app.get("/metadata")
-    async def metadata():
-        return Metadata(
-            header=header,
-            intro=intro,
-            title=title,
-            prod=prod,
-            auth=auth,
-            tier=tier,
-            analytics=analytics,
-            org=org,
-            pk_live=PK_LIVE,
-            pk_test=PK_TEST
-        )
+    @app.get("/config")
+    async def get_config():
+        return config
 
     if Path("public").is_dir():
         app.mount("/public", StaticFiles(directory="public", html=True))
-    app.mount("/", StaticFiles(directory=public_path, html=True))
+    app.mount("/", StaticFiles(directory=config.public_path, html=True))
 
     return app
 
 def serve(func, config, name, port):
     import uvicorn, logging
+    if isinstance(config, dict):
+        config = Config(**config)
     logging.getLogger("uvicorn.error").addFilter(lambda r: "0.0.0.0" not in r.getMessage())
     print(f"\n🔨 {name} => http://localhost:{port}\n")
-    uvicorn.run(web(func, *config), host="0.0.0.0", port=port)
+    uvicorn.run(web(func, config), host="0.0.0.0", port=port)

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

@@ -1,10 +1,10 @@
 [tool.poetry]
 name = "cycls"
-version = "0.0.2.64"
+version = "0.0.2.66"
 
 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}