dev -> main (Mar 29)

.env.example

@@ -126,3 +126,10 @@ INTEGRATIONS_SENTRY_DSN=<sentry_dsn>
 # API Keys needed for the `humanize_text` method in `evaluate` step
 SAPLING_API_KEY=<your_sapling_api_key>
 COPYLEAKS_API_KEY=<your_copyleaks_api_key>
+
+
+# Responses Flag
+# ---------------
+
+# Set to true to enable responses in the API
+ENABLE_RESPONSES=false

README.md

@@ -36,6 +36,21 @@
   <h3><i>Serverless AI Workflows for Data & ML Teams</i></h3>
 </div>
 
+## 🎉 Announcing: Julep Open Responses API (Alpha)
+
+<div style="padding: 15px; border-left: 4px solid #4CAF50; margin: 20px 0;">
+
+We're excited to announce the launch of our Open Responses API! This new API offers:
+
+1. **OpenAI-compatible interface** - A drop-in replacement for your existing code
+2. **Self-hosted, open-source implementation** - Works with any LLM backend
+3. **Model Provider Agnostic** - Connect to any LLM provider (OpenAI, Anthropic, etc.)
+
+The Open Responses API makes it easy to integrate with your existing applications while adding powerful new capabilities.
+
+Ready to try it out? Check out our [Open Responses API documentation](https://docs.julep.ai/responses/quickstart) to get started!
+</div>
+
 Julep is a serverless platform that helps data and ML teams build sophisticated AI workflows. It provides a robust foundation for orchestrating complex AI operations, managing state across interactions, and integrating with your existing data infrastructure and tools.
 
 Whether you're building data pipelines or creating AI workflows, Julep makes it easy to compose and scale LLM-powered workflows without managing infrastructure. Imagine you want to build an AI agent that can do more than just answer simple questions—it needs to handle complex tasks, remember past interactions, and maybe even use other tools or APIs. That's where Julep comes in. Our platform handles the heavy lifting so you can focus on building intelligent solutions for your business.

agents-api/agents_api/activities/execute_api_call.py

@@ -1,10 +1,8 @@
 import base64
-import json
 from typing import Any, TypedDict
 
 import httpx
 from beartype import beartype
-from httpx import Response
 from temporalio import activity
 
 from ..autogen.openapi_model import ApiCallDef
@@ -30,41 +28,86 @@ async def execute_api_call(
     request_args: RequestArgs,
 ) -> Any:
     try:
+        # Use client with timeout and proper error handling
         async with httpx.AsyncClient(timeout=600) as client:
-            arg_headers: dict = request_args.pop("headers", None) or {}
+            # Extract URL, method, and headers from arguments
+            arg_url = request_args.pop("url", None)
+            arg_headers = request_args.pop("headers", None)
+            arg_method = request_args.pop("method", None)
+
             # Allow the method to be overridden by the request_args
-            response: Response = await client.request(
-                method=request_args.pop("method", api_call.method),
-                url=str(request_args.pop("url", api_call.url)),
-                headers={**arg_headers, **(api_call.headers or {})},
-                follow_redirects=request_args.pop(
-                    "follow_redirects", api_call.follow_redirects
-                ),
+            method = arg_method or api_call.method
+            url = arg_url or str(api_call.url)
+
+            # Merge headers from both arguments and API call definition
+            merged_headers = (arg_headers or {}) | (api_call.headers or {})
+
+            # Allow follow_redirects to be overridden by request_args
+            follow_redirects = request_args.pop("follow_redirects", api_call.follow_redirects)
+
+            # Log the request (debug level)
+            if activity.in_activity():
+                activity.logger.debug(f"Making API call: {method} to {url}")
+
+            # Execute the HTTP request
+            response = await client.request(
+                method=method,
+                url=url,
+                headers=merged_headers,
+                follow_redirects=follow_redirects,
                 **request_args,
             )
-            # Raise an error if the response is not successful
-            response.raise_for_status()
-            # Get the content of the response
+
+            # Raise for HTTP errors
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                # For HTTP errors, include response body in the error for debugging
+                error_body = e.response.text[:500] if e.response.text else "(empty body)"
+                if activity.in_activity():
+                    activity.logger.error(
+                        f"HTTP error {e.response.status_code} in API call: {e!s}\n"
+                        f"Response body: {error_body}"
+                    )
+                raise
+
+            # Encode content as base64 for safety
             content_base64 = base64.b64encode(response.content).decode("ascii")
-            #  Create a response dict with the status code, headers, and content
+
+            # Prepare response dictionary
             response_dict = {
                 "status_code": response.status_code,
                 "headers": dict(response.headers),
                 "content": content_base64,
             }
-            # Try to parse the response as JSON
+
+            # Try to parse JSON response if possible
             try:
                 response_dict["json"] = response.json()
-            except json.JSONDecodeError as e:
+            except Exception as e:
                 response_dict["json"] = None
-                activity.logger.debug(f"Failed to parse JSON response: {e}")
+                content_preview = response.text[:100] if response.text else "(empty)"
+                if activity.in_activity():
+                    activity.logger.debug(
+                        f"Response not valid JSON: {e!s}\n"
+                        f"Content-Type: {response.headers.get('content-type')}\n"
+                        f"Content preview: {content_preview}"
+                    )
 
         return response_dict
 
-    except BaseException as e:
+    except httpx.TimeoutException as e:
         if activity.in_activity():
-            activity.logger.error(f"Error in execute_api_call: {e}")
-
+            activity.logger.error(f"Timeout in API call: {e!s}")
+        raise
+    except httpx.RequestError as e:
+        # Network-level errors
+        if activity.in_activity():
+            activity.logger.error(f"Request error in API call: {e!s}")
+        raise
+    except Exception as e:
+        if activity.in_activity():
+            activity.logger.error(f"Error in execute_api_call: {e!s}")
         raise
 
 

agents-api/agents_api/activities/task_steps/base_evaluate.py

@@ -14,38 +14,24 @@
 
 from ...common.exceptions.executions import EvaluateError
 from ...common.protocol.tasks import StepContext
+from ...common.utils.task_validation import backwards_compatibility
 from ..utils import get_evaluator
 
 
-def backwards_compatibility(expr: str) -> str:
-    expr = expr.strip()
-
-    if expr.startswith("$ "):
-        return expr
-
-    if "{{" in expr:
-        return "$ f'''" + expr.replace("{{", "{").replace("}}", "}") + "'''"
-
-    if (
-        (expr.startswith("[") and expr.endswith("]"))
-        or (expr.startswith("_[") and expr.endswith("]"))
-        or (expr.startswith("_.") and expr.endswith("]"))
-        or "outputs[" in expr
-        or "inputs[" in expr
-        or expr == "_"
-    ):
-        return "$ " + expr
-
-    return expr
-
-
 # Recursive evaluation helper function
 def _recursive_evaluate(expr, evaluator: SimpleEval):
+    # Handle PyExpression type from the model
+    if hasattr(expr, "root") and isinstance(expr.root, str):
+        # Extract the string from the RootModel
+        expr = expr.root
+
     if isinstance(expr, str):
         try:
             expr = backwards_compatibility(expr)
+            expr = expr.strip()
             if isinstance(expr, str) and expr.startswith("$ "):
-                expr = expr[2:].strip()
+                # Remove $ and any space after it
+                expr = expr[1:].strip()
             else:
                 expr = f"f'''{expr}'''"
             return evaluator.eval(expr)
@@ -79,10 +65,16 @@ async def base_evaluate(
 
     values = values or {}
     if context:
-        values.update(await context.prepare_for_step())
+        # NOTE: We limit the number of inputs to 50 to avoid excessive memory usage
+        values.update(await context.prepare_for_step(limit=50))
+
+    # Handle PyExpression objects and strings similarly
+    if isinstance(exprs, str) or (hasattr(exprs, "root") and isinstance(exprs.root, str)):
+        input_len = 1
+    else:
+        input_len = len(exprs)
 
-    input_len = 1 if isinstance(exprs, str) else len(exprs)
-    assert input_len > 0, "exprs must be a non-empty string, list or dict"
+    assert input_len > 0, "exprs must be a non-empty string, PyExpression, list or dict"
 
     extra_lambdas = {}
     if extra_lambda_strs:

agents-api/agents_api/activities/task_steps/prompt_step.py

@@ -97,6 +97,7 @@ async def prompt_step(context: StepContext) -> StepOutcome:
         exclude_unset=True,
     )
     passed_settings.update(passed_settings.pop("settings", {}) or {})
+    passed_settings["user"] = str(context.execution_input.developer_id)
 
     if not passed_settings.get("tools"):
         passed_settings.pop("tool_choice", None)