flow-platform-sdk 0.1.6__tar.gz

flow_platform_sdk-0.1.6/.bumpversion.toml

@@ -0,0 +1,26 @@
+[tool.bumpversion]
+current_version = "0.1.5"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+tag = false
+sign_tags = false
+tag_name = "release/v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = false
+message = "Bump version: {current_version} → {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[[tool.bumpversion.files]]
+filename = "src/flow_platform_sdk/__init__.py"
+search = '__version__ = "{current_version}"'
+replace = '__version__ = "{new_version}"'

flow_platform_sdk-0.1.6/.gitignore

@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+.DS_Store
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Other
+.garden
+test-reports/
+runtime_workspace/

flow_platform_sdk-0.1.6/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "python.analysis.extraPaths": [
+    "${workspaceFolder}/src"
+  ],
+  "python.autoComplete.extraPaths": [
+    "${workspaceFolder}/src"
+  ],
+  "python.defaultInterpreterPath": "${workspaceFolder}/../.venv/bin/python",
+  "python.terminal.activateEnvironment": true
+}
+

flow_platform_sdk-0.1.6/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: flow-platform-sdk
+Version: 0.1.6
+Summary: Python SDK for Uniphore Flow Platform APIs
+Author-email: Uniphore <support@uniphore.com>
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Description-Content-Type: text/markdown
+
+# Flow Platform SDK
+
+Python SDK for interacting with Uniphore Flow Platform services via async RPC.
+
+## Usage
+
+```python
+import asyncio
+from flow_platform_sdk import platform_api
+
+async def main():
+    # List data connectors
+    connectors = await platform_api.list_connectors()
+
+    # Execute SQL query
+    result = await platform_api.execute_query(
+        connector_id="conn_123",
+        sql_query="SELECT * FROM customers LIMIT 10",
+        max_rows=10
+    )
+
+    # Query knowledge base
+    answer = await platform_api.query_knowledge_base(
+        knowledge_base_id="kb_123",
+        query="What is the revenue?"
+    )
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Data Connectors
+
+```python
+# List all connectors
+await platform_api.list_connectors()
+
+# Get schema
+await platform_api.get_schema(connector_id="conn_123")
+
+# Execute query
+await platform_api.execute_query(
+    connector_id="conn_123",
+    sql_query="SELECT * FROM table",
+    max_rows=1000
+)
+
+# Discover schema
+await platform_api.discover_schema(
+    connector_id="conn_123",
+    include_sample_data=True,
+    table_filter="customer*"
+)
+
+# Get table info
+await platform_api.get_table_info(
+    connector_id="conn_123",
+    table_name="customers"
+)
+
+# Get sample data
+await platform_api.get_sample_data(
+    connector_id="conn_123",
+    table_name="customers",
+    limit=5
+)
+```
+
+### Knowledge Base
+
+```python
+# List knowledge bases
+await platform_api.list_knowledge_bases()
+
+# Query knowledge base
+await platform_api.query_knowledge_base(
+    knowledge_base_id="kb_123",
+    query="What are the main features?"
+)
+```
+
+### Agent Evaluation
+
+```python
+# Invoke agent with draft skill
+result = await platform_api.invoke_agent(
+    agent_spec_id="agent_123",
+    draft_skill_id="draft_456",
+    input_message="What is the weather today?",
+    context={"location": "San Francisco"},
+    timeout=60
+)
+```
+
+## Architecture
+
+The SDK uses stdio-based RPC for communication with backend services:
+
+- Requests sent to **stdout**: `REMOTE_SERVICE_CALL:{...}`
+- Responses read from **stdin**: `REMOTE_TOOL_RESULT:{...}`
+
+Designed for sandboxed execution environments.
+
+## Configuration
+
+- Default timeout: 120 seconds per request
+- Daemon threads for clean exit on timeout
+
+## Development
+
+```bash
+# Setup
+uv sync
+
+# Format code
+uvx ruff format .
+uvx ruff check .
+```

flow_platform_sdk-0.1.6/README.md

@@ -0,0 +1,119 @@
+# Flow Platform SDK
+
+Python SDK for interacting with Uniphore Flow Platform services via async RPC.
+
+## Usage
+
+```python
+import asyncio
+from flow_platform_sdk import platform_api
+
+async def main():
+    # List data connectors
+    connectors = await platform_api.list_connectors()
+
+    # Execute SQL query
+    result = await platform_api.execute_query(
+        connector_id="conn_123",
+        sql_query="SELECT * FROM customers LIMIT 10",
+        max_rows=10
+    )
+
+    # Query knowledge base
+    answer = await platform_api.query_knowledge_base(
+        knowledge_base_id="kb_123",
+        query="What is the revenue?"
+    )
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Data Connectors
+
+```python
+# List all connectors
+await platform_api.list_connectors()
+
+# Get schema
+await platform_api.get_schema(connector_id="conn_123")
+
+# Execute query
+await platform_api.execute_query(
+    connector_id="conn_123",
+    sql_query="SELECT * FROM table",
+    max_rows=1000
+)
+
+# Discover schema
+await platform_api.discover_schema(
+    connector_id="conn_123",
+    include_sample_data=True,
+    table_filter="customer*"
+)
+
+# Get table info
+await platform_api.get_table_info(
+    connector_id="conn_123",
+    table_name="customers"
+)
+
+# Get sample data
+await platform_api.get_sample_data(
+    connector_id="conn_123",
+    table_name="customers",
+    limit=5
+)
+```
+
+### Knowledge Base
+
+```python
+# List knowledge bases
+await platform_api.list_knowledge_bases()
+
+# Query knowledge base
+await platform_api.query_knowledge_base(
+    knowledge_base_id="kb_123",
+    query="What are the main features?"
+)
+```
+
+### Agent Evaluation
+
+```python
+# Invoke agent with draft skill
+result = await platform_api.invoke_agent(
+    agent_spec_id="agent_123",
+    draft_skill_id="draft_456",
+    input_message="What is the weather today?",
+    context={"location": "San Francisco"},
+    timeout=60
+)
+```
+
+## Architecture
+
+The SDK uses stdio-based RPC for communication with backend services:
+
+- Requests sent to **stdout**: `REMOTE_SERVICE_CALL:{...}`
+- Responses read from **stdin**: `REMOTE_TOOL_RESULT:{...}`
+
+Designed for sandboxed execution environments.
+
+## Configuration
+
+- Default timeout: 120 seconds per request
+- Daemon threads for clean exit on timeout
+
+## Development
+
+```bash
+# Setup
+uv sync
+
+# Format code
+uvx ruff format .
+uvx ruff check .
+```

flow_platform_sdk-0.1.6/RELEASE.md

@@ -0,0 +1,66 @@
+# Release Process
+
+## Prerequisites
+
+1. Install uv: `curl -LsSf https://astral.sh/uv/install.sh | sh`
+2. Install GitHub CLI: `brew install gh`
+3. Authenticate: `gh auth login`
+4. Configure PyPI trusted publishing (see below)
+
+## Creating a Release
+
+Run the release script from the `flow-platform-sdk` directory:
+
+```bash
+./release.sh [patch|minor|major]
+```
+
+Example:
+```bash
+./release.sh patch  # 0.1.0 -> 0.1.1
+./release.sh minor  # 0.1.0 -> 0.2.0
+./release.sh major  # 0.1.0 -> 1.0.0
+```
+
+### Dry Run
+
+Test without making changes:
+
+```bash
+./release.sh patch --dry-run
+```
+
+## Release Workflow
+
+1. **Run release script** → Bumps version, creates release branch, opens PR
+2. **Review and merge PR** → Automatically creates git tag and triggers deployment
+3. **GitHub Actions** → Builds package and publishes to PyPI
+
+The workflow only triggers if:
+- PR is merged from a `release/v*` branch
+- SDK files (`flow-platform-sdk/**`) were modified
+
+## PyPI Trusted Publishing Setup
+
+1. Go to https://pypi.org/manage/account/publishing/
+2. Add a new trusted publisher:
+   - **PyPI Project Name**: `flow-platform-sdk`
+   - **Owner**: `uniphore`
+   - **Repository**: `flow-agent`
+   - **Workflow name**: `sdk-release.yml`
+   - **Environment name**: (leave blank)
+
+## Manual Trigger (if auto-deployment fails)
+
+If the automatic deployment doesn't trigger after merging:
+
+```bash
+gh workflow run sdk-release.yml -f tag=release/v0.1.4
+```
+
+## Manual Publishing (emergency only)
+
+```bash
+uv build
+uv run twine upload dist/*
+```

flow_platform_sdk-0.1.6/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "flow-platform-sdk"
+version = "0.1.6"
+description = "Python SDK for Uniphore Flow Platform APIs"
+readme = "README.md"
+authors = [
+    { name = "Uniphore", email = "support@uniphore.com" }
+]
+requires-python = ">=3.10"
+
+dependencies = [
+    "httpx>=0.27.0",
+    "pydantic>=2.0.0",
+    "typing-extensions>=4.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.1.0",
+    "mypy>=1.8.0",
+    "ruff>=0.2.0",
+    "respx>=0.21.0",
+    "bump-my-version>=1.2.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+ignore = []
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

flow_platform_sdk-0.1.6/release.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+set -e
+
+# Check if gh CLI is installed
+if ! command -v gh &> /dev/null; then
+    echo "Error: GitHub CLI (gh) is not installed."
+    exit 1
+fi
+
+# Check if version type is provided
+if [ $# -eq 0 ]; then
+    echo "Usage: ./release.sh [patch|minor|major] [--dry-run]"
+    exit 1
+fi
+
+# Check if we're on main branch
+CURRENT_BRANCH=$(git branch --show-current)
+if [ "$CURRENT_BRANCH" != "main" ]; then
+    echo "Error: Release script can only be run from the main branch."
+    echo "Current branch: $CURRENT_BRANCH"
+    echo "Please checkout main and try again: git checkout main"
+    exit 1
+fi
+
+# Check if workspace is clean
+if [ -n "$(git status --porcelain)" ]; then
+    echo "Error: Working directory is not clean. Please commit or stash your changes first."
+    git status --short
+    exit 1
+fi
+
+# Ensure main is up to date
+echo "Pulling latest changes from main..."
+git pull origin main
+
+VERSION_TYPE=$1
+DRY_RUN=${2:-""}
+
+if [ "$DRY_RUN" = "--dry-run" ]; then
+    echo "DRY RUN MODE - No actual changes will be made"
+    CURRENT_VERSION=$(grep 'current_version = ' .bumpversion.toml | sed 's/current_version = "\(.*\)"/\1/')
+    echo "Current version: $CURRENT_VERSION"
+    echo "Would bump $VERSION_TYPE version..."
+    uv run bump-my-version bump $VERSION_TYPE --dry-run --allow-dirty --verbose
+    exit 0
+fi
+
+# Bump version without creating commit or tag
+echo "Bumping $VERSION_TYPE version (without commit)..."
+uv run bump-my-version bump $VERSION_TYPE
+
+# Get the new version
+NEW_VERSION=$(grep 'current_version = ' .bumpversion.toml | sed 's/current_version = "\(.*\)"/\1/')
+echo "New version: $NEW_VERSION"
+
+# Create release branch with new version number
+RELEASE_BRANCH="release/v${NEW_VERSION}"
+echo "Creating release branch: $RELEASE_BRANCH"
+
+# Delete branch if it exists locally
+if git show-ref --verify --quiet refs/heads/$RELEASE_BRANCH; then
+    echo "Branch $RELEASE_BRANCH already exists locally. Deleting..."
+    git branch -D $RELEASE_BRANCH
+fi
+
+git checkout -b $RELEASE_BRANCH
+
+# Commit the version changes
+echo "Committing version changes..."
+git add -A
+git commit -m "Release v$NEW_VERSION"
+
+# Push release branch
+echo "Pushing release branch..."
+git push --force origin $RELEASE_BRANCH
+
+# Create PR for release (manual review required)
+echo "Creating PR for release..."
+
+# Ensure gh is authenticated
+if ! gh auth status >/dev/null 2>&1; then
+    echo "GitHub CLI not authenticated. Starting authentication..."
+    gh auth login
+fi
+
+gh pr create --title "Release v${NEW_VERSION}" \
+  --body "## Pull Request Details
+**JIRA/EBUG Ticket:** https://uniphore.atlassian.net/browse/FOR-0000
+
+## Description
+**What changed:** Release version ${NEW_VERSION}
+
+**Impact:** New SDK version published to PyPI
+
+## Testing & Validation
+**How tested:** Automated version bump and build validation
+
+## Deployment
+**Plan for deployment:** Automated PyPI release via GitHub Actions" \
+  --base main
+
+echo "Release PR created!"
+echo "- Release branch: $RELEASE_BRANCH"
+echo "- PR created for manual review and merge"
+echo "- Tag and release will be created automatically when PR is merged"

flow_platform_sdk-0.1.6/src/flow_platform_sdk/__init__.py

@@ -0,0 +1,16 @@
+"""Flow Platform SDK - Python SDK for interacting with the Uniphore Platform API.
+
+Public API:
+    from flow_platform_sdk import platform_api
+
+    # Use the service directly
+    result = await platform_api.list_connectors()
+"""
+
+from .services.platform_api import PlatformApiService
+
+# Singleton service instance
+platform_api = PlatformApiService()
+
+__version__ = "0.1.5"
+__all__ = ["platform_api"]

flow_platform_sdk-0.1.6/src/flow_platform_sdk/models/__init__.py

@@ -0,0 +1,8 @@
+"""Data models for Flow Platform SDK."""
+
+from flow_platform_sdk.models.channel import ChannelRequest, ChannelResponse
+
+__all__ = [
+    "ChannelRequest",
+    "ChannelResponse",
+]

flow_platform_sdk-0.1.6/src/flow_platform_sdk/models/channel.py

@@ -0,0 +1,24 @@
+"""Data models for channel communication."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ChannelRequest(BaseModel):
+    """Request message structure for channel communication."""
+
+    id: str = Field(..., description="Unique identifier for the request")
+    operation: str = Field(..., description="Type of the operation/command")
+    service: str = Field(..., description="Type of the service the operation belong to")
+    input: dict[str, Any] = Field(
+        default_factory=dict, description="Input parameters for the request"
+    )
+
+
+class ChannelResponse(BaseModel):
+    """Response message structure for channel communication."""
+
+    id: str = Field(..., description="Request ID this response corresponds to")
+    result: dict[str, Any] | None = Field(None, description="Result data if successful")
+    error: dict[str, Any] | None = Field(None, description="Error details if failed")

flow_platform_sdk-0.1.6/src/flow_platform_sdk/services/__init__.py

@@ -0,0 +1,7 @@
+"""Service proxies for remote platform services."""
+
+from .platform_api import PlatformApiService
+
+__all__ = [
+    "PlatformApiService",
+]

flow_platform_sdk-0.1.6/src/flow_platform_sdk/services/base.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from ..session.manager import get_session
+
+
+class ServiceProxy:
+    """Base class for remote platform services."""
+
+    def __init__(self, service_name: str):
+        self.service_name = service_name
+
+    async def _invoke(self, operation: str, **params: Any) -> Any:
+        session = get_session()
+        return await session.invoke(self.service_name, operation, **params)

flow_platform_sdk-0.1.6/src/flow_platform_sdk/services/platform_api.py

@@ -0,0 +1,123 @@
+from typing import Any
+
+from .base import ServiceProxy
+
+
+class PlatformApiService(ServiceProxy):
+    def __init__(self):
+        super().__init__("platform_api")
+
+    # -------- Data Connectors --------
+
+    async def list_connectors(self) -> dict[str, Any]:
+        return await self._invoke("list_connectors")
+
+    async def get_schema(self, connector_id: str) -> dict[str, Any]:
+        return await self._invoke(
+            "get_schema",
+            connector_id=connector_id,
+        )
+
+    async def execute_query(
+        self,
+        connector_id: str,
+        sql_query: str,
+        max_rows: int = 1000,
+    ) -> dict[str, Any]:
+        return await self._invoke(
+            "execute_query",
+            connector_id=connector_id,
+            sql_query=sql_query,
+            max_rows=max_rows,
+        )
+
+    async def discover_schema(
+        self,
+        connector_id: str,
+        include_sample_data: bool = False,
+        table_filter: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._invoke(
+            "discover_schema",
+            connector_id=connector_id,
+            include_sample_data=include_sample_data,
+            table_filter=table_filter,
+        )
+
+    async def get_table_info(
+        self,
+        connector_id: str,
+        table_name: str,
+    ) -> dict[str, Any]:
+        return await self._invoke(
+            "get_table_info",
+            connector_id=connector_id,
+            table_name=table_name,
+        )
+
+    async def get_sample_data(
+        self,
+        connector_id: str,
+        table_name: str,
+        limit: int = 5,
+    ) -> dict[str, Any]:
+        return await self._invoke(
+            "get_sample_data",
+            connector_id=connector_id,
+            table_name=table_name,
+            limit=min(limit, 100),
+        )
+
+    # -------- Knowledge Base --------
+
+    async def list_knowledge_bases(self) -> dict[str, Any]:
+        return await self._invoke("list_knowledge_bases")
+
+    async def query_knowledge_base(
+        self,
+        knowledge_base_id: str,
+        query: str,
+    ) -> dict[str, Any]:
+        return await self._invoke(
+            "query_knowledge_base",
+            knowledge_base_id=knowledge_base_id,
+            query=query,
+        )
+
+    # -------- Agent Evaluation --------
+
+    async def invoke_agent(
+        self,
+        agent_spec_id: str,
+        draft_skill_id: str | None = None,
+        input_message: str = "",
+        context: dict[str, Any] | None = None,
+        timeout: int = 60,
+    ) -> dict[str, Any]:
+        """
+        Invoke an agent with optional draft skill for evaluation.
+
+        Args:
+            agent_spec_id: Agent specification ID to invoke
+            draft_skill_id: Optional draft skill ID for testing
+            input_message: User input message/query
+            context: Optional context dictionary
+            timeout: Request timeout in seconds
+
+        Returns:
+            {
+                "conversation_id": str,
+                "output": str,
+                "latency_ms": float,
+                "trace": List[Dict],
+                "error": Optional[str]
+            }
+        """
+        return await self._invoke(
+            "invoke_agent",
+            agent_spec_id=agent_spec_id,
+            draft_skill_id=draft_skill_id,
+            input_message=input_message,
+            context=context or {},
+            timeout=timeout,
+        )

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/channel/__init__.py

@@ -0,0 +1,12 @@
+"""Channel implementations for session communication."""
+
+from ...models.channel import ChannelRequest, ChannelResponse
+from .base import Channel
+from .stdio import StdioChannel
+
+__all__ = [
+    "Channel",
+    "ChannelRequest",
+    "ChannelResponse",
+    "StdioChannel",
+]

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/channel/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+from ...models.channel import ChannelRequest, ChannelResponse
+
+
+class Channel(ABC):
+    """Base class for RPC communication channels."""
+
+    @abstractmethod
+    async def request(self, message: ChannelRequest) -> ChannelResponse:
+        """Send a request and wait for a response."""
+        raise NotImplementedError

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/channel/stdio.py

@@ -0,0 +1,79 @@
+import asyncio
+import sys
+import threading
+
+from ...models.channel import ChannelRequest, ChannelResponse
+from ..protocol import encode_call, try_decode_result
+from .base import Channel
+
+TIMEOUT = 120  # seconds
+
+
+class StdioChannel(Channel):
+    """Standard I/O based channel implementation for inter-process communication.
+
+    Each request starts its own reader task that waits for the response.
+    Uses daemon threads so the program can exit even if stdin is blocked.
+    """
+
+    def _read_stdin_line(self):
+        return sys.stdin.readline()
+
+    async def _read_response(self, call_id: str, result_queue: asyncio.Queue) -> None:
+        """Read response from stdin for a specific request."""
+        loop = asyncio.get_event_loop()
+
+        try:
+            while True:
+                future = asyncio.Future()
+
+                def read_in_thread():
+                    try:
+                        line = self._read_stdin_line()
+                        loop.call_soon_threadsafe(future.set_result, line)
+                    except Exception as e:
+                        loop.call_soon_threadsafe(future.set_exception, e)
+
+                thread = threading.Thread(target=read_in_thread, daemon=True)
+                thread.start()
+
+                try:
+                    line = await asyncio.wait_for(future, timeout=1.0)
+                except asyncio.TimeoutError:
+                    continue
+
+                if not line:
+                    continue
+
+                payload = try_decode_result(line.rstrip("\n"))
+                if not payload:
+                    continue
+
+                if payload.get("id") == call_id:
+                    await result_queue.put(payload)
+                    break
+
+        except asyncio.CancelledError:
+            pass
+
+    async def request(self, message: ChannelRequest) -> ChannelResponse:
+        """Send request via stdout and wait for response via stdin."""
+        call_id = message.id
+        result_queue = asyncio.Queue()
+
+        reader_task = asyncio.create_task(self._read_response(call_id, result_queue))
+
+        try:
+            message_dict = message.model_dump()
+            print(encode_call(message_dict), flush=True)
+
+            response_dict = await asyncio.wait_for(result_queue.get(), timeout=TIMEOUT)
+
+            return ChannelResponse(**response_dict)
+
+        finally:
+            reader_task.cancel()
+            try:
+                await reader_task
+            except asyncio.CancelledError:
+                pass

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/manager.py

@@ -0,0 +1,16 @@
+from .channel import StdioChannel
+from .session import Session
+
+_session: Session | None = None
+
+
+def get_session() -> Session:
+    """Get or create singleton session with stdio channel."""
+    global _session
+
+    if _session:
+        return _session
+
+    channel = StdioChannel()
+    _session = Session(channel)
+    return _session

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/protocol.py

@@ -0,0 +1,21 @@
+import json
+from typing import Any
+
+CALL_PREFIX = "REMOTE_SERVICE_CALL:"
+RESULT_PREFIX = "REMOTE_SERVICE_RESULT:"
+
+
+def encode_call(payload: dict[str, Any]) -> str:
+    """Encode call message to JSON string."""
+    return CALL_PREFIX + json.dumps(payload, separators=(",", ":"))
+
+
+def try_decode_result(line: str) -> dict[str, Any] | None:
+    """Decode result message from JSON string."""
+    if not line.startswith(RESULT_PREFIX):
+        return None
+
+    try:
+        return json.loads(line[len(RESULT_PREFIX) :])
+    except json.JSONDecodeError:
+        return None

flow_platform_sdk-0.1.6/src/flow_platform_sdk/session/session.py

@@ -0,0 +1,36 @@
+import uuid
+from typing import Any
+
+from ..models.channel import ChannelRequest, ChannelResponse
+from .channel.base import Channel
+
+
+class Session:
+    """Session for making RPC calls through a channel."""
+
+    def __init__(self, channel: Channel):
+        self.channel = channel
+
+    async def invoke(self, service: str, operation: str, **kwargs: Any) -> Any:
+        """Invoke a remote service operation."""
+        request = ChannelRequest(
+            id=str(uuid.uuid4()),
+            service=service,
+            operation=operation,
+            input=kwargs,
+        )
+
+        try:
+            response: ChannelResponse = await self.channel.request(request)
+
+            if response.error:
+                error_msg = (
+                    response.error.get("message", str(response.error))
+                    if response.error
+                    else "Unknown error"
+                )
+                raise RuntimeError(f"Operation '{operation}' failed: {error_msg}")
+
+            return response.result
+        except Exception as e:
+            raise RuntimeError(f"Operation '{operation}' failed: {str(e)}")

flow_platform_sdk-0.1.6/tests/usage/basic_usage.py

@@ -0,0 +1,44 @@
+"""Basic usage example - shows how to use the SDK."""
+
+import asyncio
+
+from flow_platform_sdk import platform_api
+
+
+async def main():
+    """Basic SDK usage example."""
+    # Data Connectors
+    print("=== Listing Connectors ===")
+    connectors = await platform_api.list_connectors()
+    print(f"Available connectors: {connectors}\n")
+
+    # Get schema
+    print("=== Getting Schema ===")
+    schema = await platform_api.get_schema(connector_id="conn_123")
+    print(f"Schema: {schema}\n")
+
+    # Execute query
+    print("=== Executing Query ===")
+    result = await platform_api.execute_query(
+        connector_id="conn_123",
+        sql_query="SELECT * FROM customers LIMIT 10",
+        max_rows=10,
+    )
+    print(f"Query result: {result}\n")
+
+    # Knowledge Base
+    print("=== Listing Knowledge Bases ===")
+    kbs = await platform_api.list_knowledge_bases()
+    print(f"Knowledge bases: {kbs}\n")
+
+    # Query knowledge base
+    print("=== Querying Knowledge Base ===")
+    answer = await platform_api.query_knowledge_base(
+        knowledge_base_id="kb_123",
+        query="What is the company revenue?",
+    )
+    print(f"Answer: {answer}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())