fastsdk 0.4.2__tar.gz → 0.4.3__tar.gz

{fastsdk-0.4.2 → fastsdk-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsdk
-Version: 0.4.2
+Version: 0.4.3
 Summary: Turn any AI/web service (OpenAPI, Replicate, RunPod, APIPod) into a native-feeling Python client.
 Author: SocAIty
 License:                     GNU GENERAL PUBLIC LICENSE

{fastsdk-0.4.2 → fastsdk-0.4.3}/fastsdk/service_interaction/request/api_client.py

@@ -225,7 +225,6 @@ class APIClient:
             return True
         return bool(schema.get("properties"))
 
-
     def format_request_params(self, endpoint: Endpoint, data: dict) -> RequestData:
         """Prepare all request parameters for the endpoint."""
         body_content_type = getattr(endpoint, "request_body_content_type", None)
@@ -242,6 +241,8 @@ class APIClient:
         rq = RequestData(body_content_type=body_content_type)
         embed_files_in_json_body = self._uses_json_request_body(endpoint)
         body_params = [p for p in endpoint.parameters if p.location == "body"]
+        # Sole JSON object body (e.g. ChatCompletionRequest as ``request``):
+        # spread model fields onto the wire root. Callers still pass request={...}.
         single_json_object_body = (
             embed_files_in_json_body
             and len(body_params) == 1

{fastsdk-0.4.2 → fastsdk-0.4.3}/fastsdk/service_interaction/request/api_client_runpod.py

@@ -35,8 +35,16 @@ class APIClientRunpod(APIClient):
         return getattr(response, "output", None)
 
     def format_request_params(self, endpoint: Endpoint, *args, **kwargs) -> RequestData:
-        """Prepare request parameters for Runpod API."""
+        """Prepare request parameters for Runpod API.
+
+        Shared ``APIClient`` spreads a sole JSON object body onto the wire root
+        for HTTP. RunPod ``input`` is function kwargs, so re-nest that object
+        under the schema param name (usually ``request``) and keep ``path``.
+        """
         request_data = super().format_request_params(endpoint, *args, **kwargs)
+        request_data.body_params = self._renest_sole_json_object_body(
+            endpoint, request_data.body_params
+        )
 
         # adding path to the body for runpod apipod services
         if endpoint.path:
@@ -44,6 +52,26 @@ class APIClientRunpod(APIClient):
 
         return request_data
 
+    @classmethod
+    def _renest_sole_json_object_body(cls, endpoint: Endpoint, body_params: dict) -> dict:
+        body_defs = [p for p in (endpoint.parameters or []) if p.location == "body"]
+        if (
+            len(body_defs) != 1
+            or not cls._is_json_object_request_body(body_defs[0])
+        ):
+            return body_params
+
+        name = body_defs[0].name
+        if name in body_params:
+            return body_params
+
+        reserved = {"path"}
+        nested = {k: v for k, v in body_params.items() if k not in reserved}
+        keep = {k: v for k, v in body_params.items() if k in reserved}
+        if not nested:
+            return body_params
+        return {name: nested, **keep}
+
     async def send_request(self, request_data: RequestData, timeout_s: float = 60) -> httpx.Response:
         """
         Send the prepared request to the API.

{fastsdk-0.4.2 → fastsdk-0.4.3}/fastsdk/service_interaction/response/response_parser.py

@@ -12,6 +12,7 @@ Design:
 from __future__ import annotations
 
 import json
+import os
 from typing import Any, Callable, Optional, Union
 
 import httpx
@@ -29,10 +30,31 @@ from socaity_schemas import (
 # ---------------------------------------------------------------------------
 
 
+def _materialize_media() -> bool:
+    """When false (MCP / agents), keep FileModel URLs instead of downloading bytes."""
+    return os.environ.get("FASTSDK_MATERIALIZE_MEDIA", "1").strip().lower() not in {
+        "0",
+        "false",
+        "no",
+        "off",
+    }
+
+
 def _looks_like_file_model_dict(value: dict) -> bool:
     return "content" in value and ("content_type" in value or "file_name" in value)
 
 
+def _file_ref_from_model(value: dict) -> dict:
+    content = value.get("content")
+    return {
+        "url": content if isinstance(content, str) else None,
+        "content": content if isinstance(content, str) else None,
+        "content_type": value.get("content_type"),
+        "file_name": value.get("file_name"),
+        "file_size": value.get("file_size"),
+    }
+
+
 def _parse_media_socaity(result: Any) -> Any:
     if result is None:
         return result
@@ -42,12 +64,16 @@ def _parse_media_socaity(result: Any) -> Any:
     if callable(model_dump):
         dumped = model_dump()
         if isinstance(dumped, dict) and _looks_like_file_model_dict(dumped):
+            if not _materialize_media():
+                return _file_ref_from_model(dumped)
             try:
                 return media_from_any(dumped, allow_reads_from_disk=False)
             except Exception:
                 pass
     if isinstance(result, dict):
         if _looks_like_file_model_dict(result):
+            if not _materialize_media():
+                return _file_ref_from_model(result)
             try:
                 return media_from_any(result, allow_reads_from_disk=False)
             except Exception:
@@ -58,6 +84,8 @@ def _parse_media_socaity(result: Any) -> Any:
 
 def _parse_media_replicate(result: Any) -> Any:
     if isinstance(result, str) and "https://replicate.delivery" in result:
+        if not _materialize_media():
+            return {"url": result, "content": result}
         try:
             return media_from_any(result, allow_reads_from_disk=False)
         except Exception:

{fastsdk-0.4.2 → fastsdk-0.4.3}/fastsdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsdk
-Version: 0.4.2
+Version: 0.4.3
 Summary: Turn any AI/web service (OpenAPI, Replicate, RunPod, APIPod) into a native-feeling Python client.
 Author: SocAIty
 License:                     GNU GENERAL PUBLIC LICENSE

{fastsdk-0.4.2 → fastsdk-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastsdk"
-version = "0.4.2"
+version = "0.4.3"
 description = "Turn any AI/web service (OpenAPI, Replicate, RunPod, APIPod) into a native-feeling Python client."
 requires-python = ">=3.8"
 authors = [
@@ -40,10 +40,10 @@ fastsdk = "fastsdk.cli:main"
 Repository = "https://github.com/SocAIty/fastsdk"
 Homepage = "https://www.socaity.ai"
 
-[tool.setuptools.package-data]
-"fastsdk.sdk_factory" = ["*.j2"]
-
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["fastsdk*"]
 exclude = ["output*", "test*"]
+
+[tool.setuptools.package-data]
+"fastsdk.sdk_factory" = ["*.j2"]

{fastsdk-0.4.2 → fastsdk-0.4.3}/test/test_apipod_debug_test_services.py

@@ -17,6 +17,7 @@ Job polling follows the parsed contract's ``has_job_queue`` for queue-backed lau
 """
 from __future__ import annotations
 
+import json
 import os
 from pathlib import Path
 from typing import Any, Iterable, Optional
@@ -191,6 +192,15 @@ def _choice_message(result: dict) -> str:
     return result["choices"][0]["message"]["content"]
 
 
+def _collect_chunks(job) -> list[dict]:
+    """Collect the decoded ChatCompletionChunk dicts of one SSE stream."""
+    session = job.stream()
+    try:
+        return [chunk for chunk in session.iter_chunks() if isinstance(chunk, dict)]
+    finally:
+        session.close()
+
+
 def _collect_stream_text(job) -> str:
     session = job.stream()
     try:
@@ -398,6 +408,98 @@ def test_media_results_are_media_toolkit_files():
         pytest.skip("No media-returning endpoints are exposed by the current service launch")
 
 
+WEATHER_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Current weather for a city.",
+        "parameters": {
+            "type": "object",
+            "properties": {"location": {"type": "string"}},
+            "required": ["location"],
+        },
+    },
+}
+
+
+def test_chat_tool_call():
+    """Tool round trip: tool_calls result, streamed tool delta, tool-result turn."""
+    client = _client()
+    endpoint = _require_stream_endpoint(_service_def(), "/chat")
+    messages = [{"role": "user", "content": "What is the weather in Boston?"}]
+
+    # Non-stream: parsed function call and finish_reason=tool_calls.
+    result = client.submit_job(
+        endpoint.path, messages=messages, tools=[WEATHER_TOOL], stream=False,
+    ).wait_for_result(timeout_s=JOB_TIMEOUT_S)
+    choice = result["choices"][0]
+    assert choice["finish_reason"] == "tool_calls"
+    call = choice["message"]["tool_calls"][0]
+    assert call["function"]["name"] == "get_weather"
+    assert "location" in json.loads(call["function"]["arguments"])
+
+    # Stream: a chunk carries the tool_calls delta; the stream closes with tool_calls.
+    stream_job = client.submit_job(endpoint.path, messages=messages, tools=[WEATHER_TOOL], stream=True)
+    chunks = _collect_chunks(stream_job)
+    tool_deltas = [c for c in chunks if c["choices"][0].get("delta", {}).get("tool_calls")]
+    assert tool_deltas, "no tool_calls delta in stream"
+    assert tool_deltas[0]["choices"][0]["delta"]["tool_calls"][0]["function"]["name"] == "get_weather"
+    finish_reasons = [c["choices"][0].get("finish_reason") for c in chunks if c["choices"][0].get("finish_reason")]
+    assert finish_reasons[-1] == "tool_calls"
+
+    # Tool-result turn: the assistant answers from the tool output.
+    follow_up = messages + [
+        {"role": "assistant", "content": None, "tool_calls": [call]},
+        {"role": "tool", "tool_call_id": call["id"], "content": "sunny, 21 degrees"},
+    ]
+    result = client.submit_job(
+        endpoint.path, messages=follow_up, tools=[WEATHER_TOOL], stream=False,
+    ).wait_for_result(timeout_s=JOB_TIMEOUT_S)
+    assert _choice_message(result)
+
+
+def test_chat_logprobs():
+    """logprobs=True returns per-token entries with top_logprobs."""
+    client = _client()
+    endpoint = _require_stream_endpoint(_service_def(), "/chat")
+
+    result = client.submit_job(
+        endpoint.path,
+        messages=[{"role": "user", "content": "hi"}],
+        logprobs=True,
+        top_logprobs=2,
+        stream=False,
+    ).wait_for_result(timeout_s=JOB_TIMEOUT_S)
+
+    entries = result["choices"][0]["logprobs"]["content"]
+    assert entries, "empty logprobs content"
+    first = entries[0]
+    assert first["token"]
+    assert isinstance(first["logprob"], float) and first["logprob"] <= 0.0
+    assert first.get("top_logprobs"), "top_logprobs missing"
+
+
+def test_chat_reasoning():
+    """Reasoning (<think>) output lands in reasoning_content, not in content."""
+    client = _client()
+    endpoint = _require_stream_endpoint(_service_def(), "/chat")
+    messages = [{"role": "user", "content": "hi, please think first"}]
+
+    result = client.submit_job(
+        endpoint.path, messages=messages, stream=False,
+    ).wait_for_result(timeout_s=JOB_TIMEOUT_S)
+    message = result["choices"][0]["message"]
+    assert message["reasoning_content"]
+    assert message["content"] and "<think>" not in message["content"]
+
+    stream_job = client.submit_job(endpoint.path, messages=messages, stream=True)
+    chunks = _collect_chunks(stream_job)
+    reasoning = "".join(c["choices"][0].get("delta", {}).get("reasoning_content") or "" for c in chunks)
+    content = "".join(c["choices"][0].get("delta", {}).get("content") or "" for c in chunks)
+    assert reasoning
+    assert content and "<think>" not in content
+
+
 def test_connect_chat_extended():
     client = _client()
     endpoint = _endpoint_by_suffix(_service_def(), "/chat-extended")
@@ -417,6 +519,9 @@ def _main_tests() -> Iterable[str]:
         "test_streaming_text",
         "test_streaming_video",
         "test_streaming_chat_schema",
+        "test_chat_tool_call",
+        "test_chat_logprobs",
+        "test_chat_reasoning",
         "test_media_results_are_media_toolkit_files",
         "test_connect_chat_extended",
     )