deepflow-voicespeed-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepflow-voicespeed-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: Command line client for VoiceSpeed OpenAPI
 Home-page: https://github.com/DeepFlowAI/voicespeed
 License: Proprietary
@@ -36,7 +36,14 @@ voicespeed agents update 1 --name "Support Pro"
 voicespeed agents disable 1
 voicespeed agents enable 1
 voicespeed agents basic-settings 1
-voicespeed conversation run 1 --message "Hello" --mode text2text
+voicespeed conversation run 1 --message "Hello" --mode text2text \
+  --variables '{"customer_name":"Ada"}'
+voicespeed calls preset-variables 1 call_42 \
+  --variables '{"customer_name":"Ada","order_no":"A1024"}'
+voicespeed realtime-sessions create 1 --external-id call_42 \
+  --variables '{"customer_name":"Ada"}'
 ```
 
+`--variables` is a JSON object of text values. It is optional on `conversation run` and `realtime-sessions create`. `calls preset-variables` stores values for a FlowKit call before it starts; the call id is the same value later sent as `session_id`.
+
 All successful commands print formatted JSON.

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/README.md

@@ -26,7 +26,14 @@ voicespeed agents update 1 --name "Support Pro"
 voicespeed agents disable 1
 voicespeed agents enable 1
 voicespeed agents basic-settings 1
-voicespeed conversation run 1 --message "Hello" --mode text2text
+voicespeed conversation run 1 --message "Hello" --mode text2text \
+  --variables '{"customer_name":"Ada"}'
+voicespeed calls preset-variables 1 call_42 \
+  --variables '{"customer_name":"Ada","order_no":"A1024"}'
+voicespeed realtime-sessions create 1 --external-id call_42 \
+  --variables '{"customer_name":"Ada"}'
 ```
 
+`--variables` is a JSON object of text values. It is optional on `conversation run` and `realtime-sessions create`. `calls preset-variables` stores values for a FlowKit call before it starts; the call id is the same value later sent as `session_id`.
+
 All successful commands print formatted JSON.

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = deepflow-voicespeed-cli
-version = 0.1.0
+version = 0.1.2
 description = Command line client for VoiceSpeed OpenAPI
 long_description = file: README.md
 long_description_content_type = text/markdown

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/src/deepflow_voicespeed_cli/__init__.py

@@ -1,3 +1,3 @@
 """VoiceSpeed OpenAPI command line client."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/src/deepflow_voicespeed_cli/cli.py

@@ -31,6 +31,9 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(dest="resource", required=True)
     _add_agent_commands(subparsers)
     _add_conversation_commands(subparsers)
+    _add_call_commands(subparsers)
+    _add_realtime_session_commands(subparsers)
+    _add_fine_tune_commands(subparsers)
     return parser
 
 
@@ -79,9 +82,78 @@ def _add_conversation_commands(subparsers: argparse._SubParsersAction) -> None:
     run_parser.add_argument("agent_id", type=int)
     run_parser.add_argument("--message", required=True)
     run_parser.add_argument("--mode", choices=["text2text", "text2voice"], default="text2text")
+    run_parser.add_argument(
+        "--variables",
+        help='Call variables as a JSON object, e.g. \'{"customer_name":"Ada"}\'',
+    )
     run_parser.set_defaults(handler=_handle_conversation_run)
 
 
+def _add_call_commands(subparsers: argparse._SubParsersAction) -> None:
+    calls = subparsers.add_parser("calls", help="Manage a call before it starts")
+    actions = calls.add_subparsers(dest="action", required=True)
+
+    preset_parser = actions.add_parser(
+        "preset-variables",
+        help="Store call variables before the call starts",
+    )
+    preset_parser.add_argument("agent_id", type=int)
+    preset_parser.add_argument("call_id")
+    preset_parser.add_argument(
+        "--variables",
+        required=True,
+        help='Call variables as a JSON object, e.g. \'{"customer_name":"Ada"}\'',
+    )
+    preset_parser.set_defaults(handler=_handle_calls_preset_variables)
+
+
+def _add_realtime_session_commands(subparsers: argparse._SubParsersAction) -> None:
+    sessions = subparsers.add_parser(
+        "realtime-sessions",
+        help="Mint a production realtime voice session",
+    )
+    actions = sessions.add_subparsers(dest="action", required=True)
+
+    create_parser = actions.add_parser("create", help="Create a realtime session token")
+    create_parser.add_argument("agent_id", type=int)
+    create_parser.add_argument("--external-id", required=True)
+    create_parser.add_argument("--trace-id")
+    create_parser.add_argument(
+        "--variables",
+        help='Call variables as a JSON object, e.g. \'{"customer_name":"Ada"}\'',
+    )
+    create_parser.set_defaults(handler=_handle_realtime_session_create)
+
+
+def _add_fine_tune_commands(subparsers: argparse._SubParsersAction) -> None:
+    fine_tune = subparsers.add_parser("fine-tune", help="Manage fine-tune jobs")
+    actions = fine_tune.add_subparsers(dest="action", required=True)
+
+    list_parser = actions.add_parser("list", help="List fine-tune jobs")
+    list_parser.add_argument("agent_id", type=int)
+    list_parser.add_argument("--status")
+    list_parser.add_argument("--page", type=int, default=1)
+    list_parser.add_argument("--per-page", type=int, default=10)
+    list_parser.set_defaults(handler=_handle_fine_tune_list)
+
+    get_parser = actions.add_parser("get", help="Get a fine-tune job")
+    get_parser.add_argument("agent_id", type=int)
+    get_parser.add_argument("job_id", type=int)
+    get_parser.set_defaults(handler=_handle_fine_tune_get)
+
+    create_parser = actions.add_parser("create", help="Create a fine-tune job")
+    create_parser.add_argument("agent_id", type=int)
+    create_parser.add_argument("--name", required=True)
+    create_parser.add_argument("--file", required=True, help="Path to JSONL training file")
+    create_parser.add_argument("--n-epochs", type=int, default=3)
+    create_parser.add_argument("--model-suffix")
+    create_parser.add_argument(
+        "--train-params",
+        help="Advanced training params as JSON string",
+    )
+    create_parser.set_defaults(handler=_handle_fine_tune_create)
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
@@ -174,6 +246,83 @@ def _handle_conversation_run(
         args.agent_id,
         message=args.message,
         mode=args.mode,
+        variables=_parse_variables(args.variables),
+    )
+
+
+def _handle_calls_preset_variables(
+    client: VoiceSpeedClient,
+    args: argparse.Namespace,
+) -> Any:
+    return client.preset_call_variables(
+        args.agent_id,
+        args.call_id,
+        variables=_parse_variables(args.variables) or {},
+    )
+
+
+def _handle_realtime_session_create(
+    client: VoiceSpeedClient,
+    args: argparse.Namespace,
+) -> Any:
+    return client.create_realtime_session(
+        args.agent_id,
+        external_id=args.external_id,
+        trace_id=args.trace_id,
+        variables=_parse_variables(args.variables),
+    )
+
+
+def _parse_variables(raw: str | None) -> dict[str, str] | None:
+    if raw is None:
+        return None
+    try:
+        value = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise CliError("variables must be valid JSON") from exc
+    if not isinstance(value, dict) or any(not isinstance(item, str) for item in value.values()):
+        raise CliError("variables must be a JSON object of text values")
+    return value
+
+
+def _handle_fine_tune_list(
+    client: VoiceSpeedClient,
+    args: argparse.Namespace,
+) -> Any:
+    return client.list_fine_tune_jobs(
+        args.agent_id,
+        status=args.status,
+        page=args.page,
+        per_page=args.per_page,
+    )
+
+
+def _handle_fine_tune_get(
+    client: VoiceSpeedClient,
+    args: argparse.Namespace,
+) -> Any:
+    return client.get_fine_tune_job(args.agent_id, args.job_id)
+
+
+def _handle_fine_tune_create(
+    client: VoiceSpeedClient,
+    args: argparse.Namespace,
+) -> Any:
+    train_params = None
+    if args.train_params:
+        try:
+            train_params = json.loads(args.train_params)
+        except json.JSONDecodeError as exc:
+            raise CliError("train_params must be valid JSON") from exc
+        if not isinstance(train_params, dict):
+            raise CliError("train_params must be a JSON object")
+    return client.create_fine_tune_job(
+        args.agent_id,
+        name=args.name,
+        file_path=args.file,
+        n_epochs=args.n_epochs,
+        model_suffix=args.model_suffix,
+        train_params=train_params,
     )
 
 

deepflow_voicespeed_cli-0.1.2/src/deepflow_voicespeed_cli/client.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+from uuid import uuid4
+
+
+class VoiceSpeedClientError(Exception):
+    """Base error raised by the VoiceSpeed client."""
+
+
+class VoiceSpeedApiError(VoiceSpeedClientError):
+    def __init__(self, status_code: int, body: str) -> None:
+        self.status_code = status_code
+        self.body = body
+        super().__init__(f"HTTP {status_code}: {body}")
+
+
+class VoiceSpeedRequestError(VoiceSpeedClientError):
+    pass
+
+
+@dataclass
+class VoiceSpeedClient:
+    base_url: str
+    api_key: str
+    timeout: float = 30.0
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+        self.api_key = self.api_key.strip()
+        if not self.api_key:
+            raise ValueError("Missing API key")
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: dict[str, Any] | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> Any:
+        url = f"{self.base_url}/api/v1/openapi{path}"
+        clean_query = {
+            key: value for key, value in (query or {}).items() if value is not None
+        }
+        if clean_query:
+            url = f"{url}?{urlencode(clean_query)}"
+
+        body = None
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        if payload is not None:
+            body = json.dumps(payload).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        req = Request(url, data=body, headers=headers, method=method.upper())
+        try:
+            with urlopen(req, timeout=self.timeout) as resp:
+                return self._parse_response(resp.read())
+        except HTTPError as exc:
+            raise VoiceSpeedApiError(exc.code, self._read_error_body(exc)) from exc
+        except URLError as exc:
+            raise VoiceSpeedRequestError(str(exc.reason)) from exc
+        except OSError as exc:
+            raise VoiceSpeedRequestError(str(exc)) from exc
+
+    def list_agents(
+        self,
+        *,
+        status: str | None = None,
+        page: int = 1,
+        per_page: int = 20,
+    ) -> Any:
+        return self.request(
+            "GET",
+            "/agents",
+            query={"status": status, "page": page, "per_page": per_page},
+        )
+
+    def create_agent(self, *, name: str, description: str | None = None) -> Any:
+        return self.request(
+            "POST",
+            "/agents",
+            payload={"name": name, "description": description},
+        )
+
+    def update_agent(
+        self,
+        agent_id: int,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Any:
+        payload = {
+            key: value
+            for key, value in {"name": name, "description": description}.items()
+            if value is not None
+        }
+        return self.request("PATCH", f"/agents/{agent_id}", payload=payload)
+
+    def set_agent_enabled(self, agent_id: int, *, enabled: bool) -> Any:
+        action = "enable" if enabled else "disable"
+        return self.request("POST", f"/agents/{agent_id}/{action}")
+
+    def get_basic_settings(self, agent_id: int) -> Any:
+        return self.request("GET", f"/agents/{agent_id}/basic-settings")
+
+    def run_conversation(
+        self,
+        agent_id: int,
+        *,
+        message: str,
+        mode: str = "text2text",
+        variables: dict[str, str] | None = None,
+    ) -> Any:
+        payload: dict[str, Any] = {"message": message, "mode": mode}
+        if variables is not None:
+            payload["variables"] = variables
+        return self.request(
+            "POST",
+            f"/agents/{agent_id}/conversation",
+            payload=payload,
+        )
+
+    def preset_call_variables(
+        self,
+        agent_id: int,
+        call_id: str,
+        *,
+        variables: dict[str, str],
+    ) -> Any:
+        encoded_call_id = quote(call_id, safe="")
+        return self.request(
+            "PUT",
+            f"/agents/{agent_id}/calls/{encoded_call_id}/variables",
+            payload={"variables": variables},
+        )
+
+    def create_realtime_session(
+        self,
+        agent_id: int,
+        *,
+        external_id: str,
+        trace_id: str | None = None,
+        variables: dict[str, str] | None = None,
+    ) -> Any:
+        payload: dict[str, Any] = {"external_id": external_id}
+        if trace_id is not None:
+            payload["trace_id"] = trace_id
+        if variables is not None:
+            payload["variables"] = variables
+        return self.request(
+            "POST",
+            f"/agents/{agent_id}/realtime-sessions",
+            payload=payload,
+        )
+
+    def list_fine_tune_jobs(
+        self,
+        agent_id: int,
+        *,
+        status: str | None = None,
+        page: int = 1,
+        per_page: int = 10,
+    ) -> Any:
+        return self.request(
+            "GET",
+            f"/agents/{agent_id}/fine-tune-jobs",
+            query={"status": status, "page": page, "per_page": per_page},
+        )
+
+    def get_fine_tune_job(self, agent_id: int, job_id: int) -> Any:
+        return self.request("GET", f"/agents/{agent_id}/fine-tune-jobs/{job_id}")
+
+    def create_fine_tune_job(
+        self,
+        agent_id: int,
+        *,
+        name: str,
+        file_path: str,
+        n_epochs: int = 3,
+        model_suffix: str | None = None,
+        train_params: dict[str, Any] | None = None,
+        timeout: float | None = None,
+    ) -> Any:
+        fields: dict[str, str] = {
+            "name": name,
+            "n_epochs": str(n_epochs),
+        }
+        if model_suffix:
+            fields["model_suffix"] = model_suffix
+        if train_params:
+            fields["train_params"] = json.dumps(train_params, ensure_ascii=False)
+
+        with open(file_path, "rb") as fh:
+            file_bytes = fh.read()
+        filename = file_path.rsplit("/", 1)[-1]
+        return self.request_multipart(
+            "POST",
+            f"/agents/{agent_id}/fine-tune-jobs",
+            fields=fields,
+            files={"file": (filename, file_bytes, "application/jsonl")},
+            timeout=timeout if timeout is not None else 600.0,
+        )
+
+    def request_multipart(
+        self,
+        method: str,
+        path: str,
+        *,
+        fields: dict[str, str],
+        files: dict[str, tuple[str, bytes, str]],
+        timeout: float | None = None,
+    ) -> Any:
+        url = f"{self.base_url}/api/v1/openapi{path}"
+        body, content_type = _encode_multipart(fields, files)
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": content_type,
+        }
+        req = Request(url, data=body, headers=headers, method=method.upper())
+        effective_timeout = self.timeout if timeout is None else timeout
+        try:
+            with urlopen(req, timeout=effective_timeout) as resp:
+                return self._parse_response(resp.read())
+        except HTTPError as exc:
+            raise VoiceSpeedApiError(exc.code, self._read_error_body(exc)) from exc
+        except URLError as exc:
+            raise VoiceSpeedRequestError(str(exc.reason)) from exc
+        except OSError as exc:
+            raise VoiceSpeedRequestError(str(exc)) from exc
+
+    @staticmethod
+    def _parse_response(data: bytes) -> Any:
+        if not data:
+            return None
+        text = data.decode("utf-8")
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            return text
+
+    @staticmethod
+    def _read_error_body(exc: HTTPError) -> str:
+        body = exc.read()
+        if not body:
+            return exc.reason
+        return body.decode("utf-8", errors="replace")
+
+
+def _encode_multipart(
+    fields: dict[str, str],
+    files: dict[str, tuple[str, bytes, str]],
+) -> tuple[bytes, str]:
+    boundary = uuid4().hex
+    chunks: list[bytes] = []
+    for key, value in fields.items():
+        chunks.extend(
+            [
+                f"--{boundary}\r\n".encode(),
+                f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode(),
+                value.encode(),
+                b"\r\n",
+            ]
+        )
+    for key, (filename, data, content_type) in files.items():
+        chunks.extend(
+            [
+                f"--{boundary}\r\n".encode(),
+                (
+                    f'Content-Disposition: form-data; name="{key}"; '
+                    f'filename="{filename}"\r\n'
+                ).encode(),
+                f"Content-Type: {content_type}\r\n\r\n".encode(),
+                data,
+                b"\r\n",
+            ]
+        )
+    chunks.append(f"--{boundary}--\r\n".encode())
+    return b"".join(chunks), f"multipart/form-data; boundary={boundary}"

{deepflow_voicespeed_cli-0.1.0 → deepflow_voicespeed_cli-0.1.2}/src/deepflow_voicespeed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepflow-voicespeed-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: Command line client for VoiceSpeed OpenAPI
 Home-page: https://github.com/DeepFlowAI/voicespeed
 License: Proprietary
@@ -36,7 +36,14 @@ voicespeed agents update 1 --name "Support Pro"
 voicespeed agents disable 1
 voicespeed agents enable 1
 voicespeed agents basic-settings 1
-voicespeed conversation run 1 --message "Hello" --mode text2text
+voicespeed conversation run 1 --message "Hello" --mode text2text \
+  --variables '{"customer_name":"Ada"}'
+voicespeed calls preset-variables 1 call_42 \
+  --variables '{"customer_name":"Ada","order_no":"A1024"}'
+voicespeed realtime-sessions create 1 --external-id call_42 \
+  --variables '{"customer_name":"Ada"}'
 ```
 
+`--variables` is a JSON object of text values. It is optional on `conversation run` and `realtime-sessions create`. `calls preset-variables` stores values for a FlowKit call before it starts; the call id is the same value later sent as `session_id`.
+
 All successful commands print formatted JSON.

deepflow_voicespeed_cli-0.1.2/tests/test_cli.py

@@ -0,0 +1,358 @@
+import json
+from unittest.mock import Mock, patch
+
+from deepflow_voicespeed_cli import cli
+from deepflow_voicespeed_cli.client import VoiceSpeedApiError, VoiceSpeedClient
+
+
+def test_agents_list_calls_client_and_prints_json(capsys):
+    client = Mock()
+    client.list_agents.return_value = {"items": [{"id": 1, "name": "Support"}]}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "agents",
+                "list",
+                "--status",
+                "enabled",
+            ]
+        )
+
+    assert code == 0
+    client.list_agents.assert_called_once_with(status="enabled", page=1, per_page=20)
+    assert json.loads(capsys.readouterr().out)["items"][0]["name"] == "Support"
+
+
+def test_missing_api_key_returns_error(monkeypatch, capsys):
+    monkeypatch.delenv("VOICESPEED_API_KEY", raising=False)
+
+    code = cli.main(["agents", "list"])
+
+    assert code == 1
+    assert "Missing API key" in capsys.readouterr().err
+
+
+def test_update_requires_at_least_one_field(capsys):
+    code = cli.main(["--api-key", "vsk_test", "agents", "update", "1"])
+
+    assert code == 1
+    assert "At least one" in capsys.readouterr().err
+
+
+def test_http_error_returns_nonzero(capsys):
+    client = Mock()
+    client.list_agents.side_effect = VoiceSpeedApiError(403, '{"code":"FORBIDDEN"}')
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(["--api-key", "vsk_test", "agents", "list"])
+
+    assert code == 1
+    assert "HTTP 403" in capsys.readouterr().err
+
+
+def test_client_builds_json_request():
+    captured = {}
+
+    class FakeResponse:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, _exc_type, _exc, _tb):
+            return None
+
+        def read(self):
+            return b'{"id": 1, "name": "Support"}'
+
+    def fake_urlopen(req, timeout):
+        captured["req"] = req
+        captured["timeout"] = timeout
+        return FakeResponse()
+
+    with patch("deepflow_voicespeed_cli.client.urlopen", fake_urlopen):
+        client = VoiceSpeedClient("http://example.com/", "vsk_test", timeout=12)
+        result = client.create_agent(name="Support", description="Demo")
+
+    req = captured["req"]
+    assert result["id"] == 1
+    assert captured["timeout"] == 12
+    assert req.get_method() == "POST"
+    assert req.full_url == "http://example.com/api/v1/openapi/agents"
+    assert req.headers["Authorization"] == "Bearer vsk_test"
+    assert json.loads(req.data.decode("utf-8")) == {
+        "name": "Support",
+        "description": "Demo",
+    }
+
+
+def test_conversation_run_command():
+    client = Mock()
+    client.run_conversation.return_value = {"reply": "hi"}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "conversation",
+                "run",
+                "3",
+                "--message",
+                "hello",
+                "--mode",
+                "text2voice",
+            ]
+        )
+
+    assert code == 0
+    client.run_conversation.assert_called_once_with(
+        3,
+        message="hello",
+        mode="text2voice",
+        variables=None,
+    )
+
+
+def test_conversation_run_passes_variables():
+    client = Mock()
+    client.run_conversation.return_value = {"reply": "hi"}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "conversation",
+                "run",
+                "3",
+                "--message",
+                "hello",
+                "--variables",
+                '{"customer_name":"Ada"}',
+            ]
+        )
+
+    assert code == 0
+    client.run_conversation.assert_called_once_with(
+        3,
+        message="hello",
+        mode="text2text",
+        variables={"customer_name": "Ada"},
+    )
+
+
+def test_variables_must_be_text_object(capsys):
+    code = cli.main(
+        [
+            "--api-key",
+            "vsk_test",
+            "conversation",
+            "run",
+            "3",
+            "--message",
+            "hello",
+            "--variables",
+            '{"customer_name":1}',
+        ]
+    )
+
+    assert code == 1
+    assert "text values" in capsys.readouterr().err
+
+
+def test_calls_preset_variables_command():
+    client = Mock()
+    client.preset_call_variables.return_value = {"call_id": "call/42", "expires_at": "t"}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "calls",
+                "preset-variables",
+                "3",
+                "call/42",
+                "--variables",
+                '{"customer_name":"Ada"}',
+            ]
+        )
+
+    assert code == 0
+    client.preset_call_variables.assert_called_once_with(
+        3,
+        "call/42",
+        variables={"customer_name": "Ada"},
+    )
+
+
+def test_realtime_session_create_command():
+    client = Mock()
+    client.create_realtime_session.return_value = {"session_id": "call_42", "token": "t"}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "realtime-sessions",
+                "create",
+                "3",
+                "--external-id",
+                "call_42",
+                "--trace-id",
+                "abc",
+                "--variables",
+                '{"customer_name":"Ada"}',
+            ]
+        )
+
+    assert code == 0
+    client.create_realtime_session.assert_called_once_with(
+        3,
+        external_id="call_42",
+        trace_id="abc",
+        variables={"customer_name": "Ada"},
+    )
+
+
+def test_fine_tune_list_command():
+    client = Mock()
+    client.list_fine_tune_jobs.return_value = {"items": [{"id": 12, "status": "running"}]}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "fine-tune",
+                "list",
+                "1",
+                "--status",
+                "running",
+            ]
+        )
+
+    assert code == 0
+    client.list_fine_tune_jobs.assert_called_once_with(
+        1,
+        status="running",
+        page=1,
+        per_page=10,
+    )
+
+
+def test_fine_tune_create_command(tmp_path):
+    train_file = tmp_path / "train.jsonl"
+    train_file.write_text('{"messages":[]}\n', encoding="utf-8")
+    client = Mock()
+    client.create_fine_tune_job.return_value = {"id": 12, "status": "uploading"}
+
+    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
+        code = cli.main(
+            [
+                "--api-key",
+                "vsk_test",
+                "fine-tune",
+                "create",
+                "1",
+                "--name",
+                "Support FT",
+                "--file",
+                str(train_file),
+                "--train-params",
+                '{"lora_r": 16}',
+            ]
+        )
+
+    assert code == 0
+    client.create_fine_tune_job.assert_called_once_with(
+        1,
+        name="Support FT",
+        file_path=str(train_file),
+        n_epochs=3,
+        model_suffix=None,
+        train_params={"lora_r": 16},
+    )
+
+
+def test_client_create_fine_tune_job_uses_multipart(tmp_path):
+    train_file = tmp_path / "train.jsonl"
+    train_file.write_text('{"messages":[]}\n', encoding="utf-8")
+    captured = {}
+
+    class FakeResponse:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, _exc_type, _exc, _tb):
+            return None
+
+        def read(self):
+            return b'{"id": 12, "status": "uploading"}'
+
+    def fake_urlopen(req, timeout):
+        captured["req"] = req
+        captured["timeout"] = timeout
+        return FakeResponse()
+
+    with patch("deepflow_voicespeed_cli.client.urlopen", fake_urlopen):
+        client = VoiceSpeedClient("http://example.com/", "vsk_test")
+        result = client.create_fine_tune_job(
+            1,
+            name="Support FT",
+            file_path=str(train_file),
+            train_params={"lora_r": 16},
+        )
+
+    req = captured["req"]
+    assert result["id"] == 12
+    assert captured["timeout"] == 600.0
+    assert req.get_method() == "POST"
+    assert req.full_url == "http://example.com/api/v1/openapi/agents/1/fine-tune-jobs"
+    assert req.headers["Authorization"] == "Bearer vsk_test"
+    assert "multipart/form-data" in req.headers["Content-type"]
+    body = req.data.decode("utf-8")
+    assert 'name="name"' in body
+    assert "Support FT" in body
+    assert 'filename="train.jsonl"' in body
+
+
+def test_client_sends_call_variables():
+    captured = []
+
+    class FakeResponse:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, _exc_type, _exc, _tb):
+            return None
+
+        def read(self):
+            return b"{}"
+
+    def fake_urlopen(req, timeout):
+        captured.append(req)
+        return FakeResponse()
+
+    with patch("deepflow_voicespeed_cli.client.urlopen", fake_urlopen):
+        client = VoiceSpeedClient("http://example.com/", "vsk_test")
+        client.run_conversation(3, message="hello", variables={"customer_name": "Ada"})
+        client.preset_call_variables(3, "call/42", variables={"customer_name": "Ada"})
+        client.create_realtime_session(3, external_id="call_42", variables={"order_no": "A1"})
+
+    conversation, preset, realtime = captured
+    assert conversation.full_url == "http://example.com/api/v1/openapi/agents/3/conversation"
+    assert json.loads(conversation.data.decode("utf-8"))["variables"] == {"customer_name": "Ada"}
+    assert preset.get_method() == "PUT"
+    assert preset.full_url == (
+        "http://example.com/api/v1/openapi/agents/3/calls/call%2F42/variables"
+    )
+    assert realtime.get_method() == "POST"
+    assert realtime.full_url == "http://example.com/api/v1/openapi/agents/3/realtime-sessions"
+    assert json.loads(realtime.data.decode("utf-8")) == {
+        "external_id": "call_42",
+        "variables": {"order_no": "A1"},
+    }

deepflow_voicespeed_cli-0.1.0/src/deepflow_voicespeed_cli/client.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from typing import Any
-from urllib.error import HTTPError, URLError
-from urllib.parse import urlencode
-from urllib.request import Request, urlopen
-
-
-class VoiceSpeedClientError(Exception):
-    """Base error raised by the VoiceSpeed client."""
-
-
-class VoiceSpeedApiError(VoiceSpeedClientError):
-    def __init__(self, status_code: int, body: str) -> None:
-        self.status_code = status_code
-        self.body = body
-        super().__init__(f"HTTP {status_code}: {body}")
-
-
-class VoiceSpeedRequestError(VoiceSpeedClientError):
-    pass
-
-
-@dataclass
-class VoiceSpeedClient:
-    base_url: str
-    api_key: str
-    timeout: float = 30.0
-
-    def __post_init__(self) -> None:
-        self.base_url = self.base_url.rstrip("/")
-        self.api_key = self.api_key.strip()
-        if not self.api_key:
-            raise ValueError("Missing API key")
-
-    def request(
-        self,
-        method: str,
-        path: str,
-        *,
-        query: dict[str, Any] | None = None,
-        payload: dict[str, Any] | None = None,
-    ) -> Any:
-        url = f"{self.base_url}/api/v1/openapi{path}"
-        clean_query = {
-            key: value for key, value in (query or {}).items() if value is not None
-        }
-        if clean_query:
-            url = f"{url}?{urlencode(clean_query)}"
-
-        body = None
-        headers = {
-            "Accept": "application/json",
-            "Authorization": f"Bearer {self.api_key}",
-        }
-        if payload is not None:
-            body = json.dumps(payload).encode("utf-8")
-            headers["Content-Type"] = "application/json"
-
-        req = Request(url, data=body, headers=headers, method=method.upper())
-        try:
-            with urlopen(req, timeout=self.timeout) as resp:
-                return self._parse_response(resp.read())
-        except HTTPError as exc:
-            raise VoiceSpeedApiError(exc.code, self._read_error_body(exc)) from exc
-        except URLError as exc:
-            raise VoiceSpeedRequestError(str(exc.reason)) from exc
-        except OSError as exc:
-            raise VoiceSpeedRequestError(str(exc)) from exc
-
-    def list_agents(
-        self,
-        *,
-        status: str | None = None,
-        page: int = 1,
-        per_page: int = 20,
-    ) -> Any:
-        return self.request(
-            "GET",
-            "/agents",
-            query={"status": status, "page": page, "per_page": per_page},
-        )
-
-    def create_agent(self, *, name: str, description: str | None = None) -> Any:
-        return self.request(
-            "POST",
-            "/agents",
-            payload={"name": name, "description": description},
-        )
-
-    def update_agent(
-        self,
-        agent_id: int,
-        *,
-        name: str | None = None,
-        description: str | None = None,
-    ) -> Any:
-        payload = {
-            key: value
-            for key, value in {"name": name, "description": description}.items()
-            if value is not None
-        }
-        return self.request("PATCH", f"/agents/{agent_id}", payload=payload)
-
-    def set_agent_enabled(self, agent_id: int, *, enabled: bool) -> Any:
-        action = "enable" if enabled else "disable"
-        return self.request("POST", f"/agents/{agent_id}/{action}")
-
-    def get_basic_settings(self, agent_id: int) -> Any:
-        return self.request("GET", f"/agents/{agent_id}/basic-settings")
-
-    def run_conversation(
-        self,
-        agent_id: int,
-        *,
-        message: str,
-        mode: str = "text2text",
-    ) -> Any:
-        return self.request(
-            "POST",
-            f"/agents/{agent_id}/conversation",
-            payload={"message": message, "mode": mode},
-        )
-
-    @staticmethod
-    def _parse_response(data: bytes) -> Any:
-        if not data:
-            return None
-        text = data.decode("utf-8")
-        try:
-            return json.loads(text)
-        except json.JSONDecodeError:
-            return text
-
-    @staticmethod
-    def _read_error_body(exc: HTTPError) -> str:
-        body = exc.read()
-        if not body:
-            return exc.reason
-        return body.decode("utf-8", errors="replace")

deepflow_voicespeed_cli-0.1.0/tests/test_cli.py

@@ -1,114 +0,0 @@
-import json
-from unittest.mock import Mock, patch
-
-from deepflow_voicespeed_cli import cli
-from deepflow_voicespeed_cli.client import VoiceSpeedApiError, VoiceSpeedClient
-
-
-def test_agents_list_calls_client_and_prints_json(capsys):
-    client = Mock()
-    client.list_agents.return_value = {"items": [{"id": 1, "name": "Support"}]}
-
-    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
-        code = cli.main(
-            [
-                "--api-key",
-                "vsk_test",
-                "agents",
-                "list",
-                "--status",
-                "enabled",
-            ]
-        )
-
-    assert code == 0
-    client.list_agents.assert_called_once_with(status="enabled", page=1, per_page=20)
-    assert json.loads(capsys.readouterr().out)["items"][0]["name"] == "Support"
-
-
-def test_missing_api_key_returns_error(monkeypatch, capsys):
-    monkeypatch.delenv("VOICESPEED_API_KEY", raising=False)
-
-    code = cli.main(["agents", "list"])
-
-    assert code == 1
-    assert "Missing API key" in capsys.readouterr().err
-
-
-def test_update_requires_at_least_one_field(capsys):
-    code = cli.main(["--api-key", "vsk_test", "agents", "update", "1"])
-
-    assert code == 1
-    assert "At least one" in capsys.readouterr().err
-
-
-def test_http_error_returns_nonzero(capsys):
-    client = Mock()
-    client.list_agents.side_effect = VoiceSpeedApiError(403, '{"code":"FORBIDDEN"}')
-
-    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
-        code = cli.main(["--api-key", "vsk_test", "agents", "list"])
-
-    assert code == 1
-    assert "HTTP 403" in capsys.readouterr().err
-
-
-def test_client_builds_json_request():
-    captured = {}
-
-    class FakeResponse:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, _exc_type, _exc, _tb):
-            return None
-
-        def read(self):
-            return b'{"id": 1, "name": "Support"}'
-
-    def fake_urlopen(req, timeout):
-        captured["req"] = req
-        captured["timeout"] = timeout
-        return FakeResponse()
-
-    with patch("deepflow_voicespeed_cli.client.urlopen", fake_urlopen):
-        client = VoiceSpeedClient("http://example.com/", "vsk_test", timeout=12)
-        result = client.create_agent(name="Support", description="Demo")
-
-    req = captured["req"]
-    assert result["id"] == 1
-    assert captured["timeout"] == 12
-    assert req.get_method() == "POST"
-    assert req.full_url == "http://example.com/api/v1/openapi/agents"
-    assert req.headers["Authorization"] == "Bearer vsk_test"
-    assert json.loads(req.data.decode("utf-8")) == {
-        "name": "Support",
-        "description": "Demo",
-    }
-
-
-def test_conversation_run_command():
-    client = Mock()
-    client.run_conversation.return_value = {"reply": "hi"}
-
-    with patch("deepflow_voicespeed_cli.cli.VoiceSpeedClient", return_value=client):
-        code = cli.main(
-            [
-                "--api-key",
-                "vsk_test",
-                "conversation",
-                "run",
-                "3",
-                "--message",
-                "hello",
-                "--mode",
-                "text2voice",
-            ]
-        )
-
-    assert code == 0
-    client.run_conversation.assert_called_once_with(
-        3,
-        message="hello",
-        mode="text2voice",
-    )