From c9501f2b5e7c1bd59ce774dca73cf80eef8f552b Mon Sep 17 00:00:00 2001 From: sawradip Date: Thu, 13 Nov 2025 04:04:32 +0600 Subject: [PATCH 1/3] feat: enhance serialization handling in client and server components - Added structured serialization and deserialization methods in RunAgentClient and SocketClient to improve data handling. - Updated LocalServer to use structured output for serialization. - Modified socket_utils to send structured data to clients, ensuring compatibility with remote executions. --- runagent/client/client.py | 10 +++++- runagent/sdk/server/local_server.py | 9 +++--- runagent/sdk/server/socket_utils.py | 12 +++---- runagent/sdk/socket_client.py | 50 ++++++++++++++++++++++++++--- 4 files changed, 66 insertions(+), 15 deletions(-) diff --git a/runagent/client/client.py b/runagent/client/client.py index 6cdf6e8..bb47283 100644 --- a/runagent/client/client.py +++ b/runagent/client/client.py @@ -80,7 +80,15 @@ def run(self, *input_args, **input_kwargs): else: # Fallback to old format for backward compatibility response_data = response.get("output_data") - return self.serializer.deserialize_object(response_data) + + if response_data is None: + return None + + try: + return self.serializer.deserialize_object_from_structured(response_data) + except Exception: + # Backward compatibility with legacy plain JSON responses + return self.serializer.deserialize_object(response_data) else: # Handle new error format with ErrorDetail object diff --git a/runagent/sdk/server/local_server.py b/runagent/sdk/server/local_server.py index c4cce58..7459808 100644 --- a/runagent/sdk/server/local_server.py +++ b/runagent/sdk/server/local_server.py @@ -760,7 +760,7 @@ async def run_agent(request: AgentRunRequest): *request.input_args, **request.input_kwargs ) - result_str = self.serializer.serialize_object(result_data) + structured_output_json = self.serializer.serialize_object_to_structured(result_data) execution_time = time.time() - start_time execution_success = True self.log_execution_complete(invocation_id, True, execution_time) @@ -821,6 +821,7 @@ async def run_agent(request: AgentRunRequest): # Wrap in standard format matching remote executions result_data_dict = { "data": actual_data, + "structured_output": structured_output_json, "type": "result", "timestamp": datetime.now().isoformat() + "Z" } @@ -871,7 +872,7 @@ async def run_agent(request: AgentRunRequest): self.db_service.record_agent_run( agent_id=self.agent_id, input_data=serializable_input, - output_data=result_str, + output_data=structured_output_json, success=True, execution_time=execution_time, ) @@ -900,7 +901,7 @@ async def run_agent(request: AgentRunRequest): }, result_data={ "message": "", - "data": result_str, + "data": structured_output_json, "vm_id": str(uuid.uuid4()), "type": "result", "timestamp": datetime.now().isoformat() @@ -924,7 +925,7 @@ async def run_agent(request: AgentRunRequest): success=True, result={ "message": "", - "data": result_str, + "data": structured_output_json, "vm_id": str(uuid.uuid4()), "type": "result", "timestamp": datetime.now().isoformat() diff --git a/runagent/sdk/server/socket_utils.py b/runagent/sdk/server/socket_utils.py index 211b166..5fddc91 100644 --- a/runagent/sdk/server/socket_utils.py +++ b/runagent/sdk/server/socket_utils.py @@ -191,15 +191,15 @@ async def handle_agent_stream_with_tracking( except Exception as e: console.print(f"Warning: Could not store chunk {chunk_count}: {e}") - # Send chunk to client + # Send chunk to client using structured serialization try: - await websocket.send_text(json.dumps({ + structured_chunk = self.serializer.serialize_object_to_structured(serializable_chunk) + await websocket.send_json({ "type": "data", - "content": serializable_chunk - })) + "content": structured_chunk + }) except Exception as send_error: console.print(f"Error sending chunk {chunk_count}: {send_error}") - # Try sending error message await websocket.send_json({ "type": "error", "error": f"Chunk serialization failed: {str(send_error)}" @@ -315,7 +315,7 @@ async def handle_agent_stream_with_tracking( import traceback traceback.print_exc() - # Send completion status + # Send completion status (remote-compatible) await websocket.send_json({ "type": "status", "status": "stream_completed", diff --git a/runagent/sdk/socket_client.py b/runagent/sdk/socket_client.py index 92a277f..4c33247 100644 --- a/runagent/sdk/socket_client.py +++ b/runagent/sdk/socket_client.py @@ -121,8 +121,30 @@ async def run_stream_async(self, agent_id: str, entrypoint_tag: str, *input_args self._debug("Stream started") continue elif message_type == "data": - # Yield the actual chunk data - yield message.get("content") + content = message.get("content") + if content is None: + yield None + else: + # Try structured deserialization first + if isinstance(content, str): + try: + yield self.serializer.deserialize_object_from_structured(content) + continue + except Exception: + pass + try: + yield self.serializer.deserialize_object(content) + continue + except Exception: + yield content + continue + # Non-string content (fallback/legacy) + try: + yield self.serializer.deserialize_object(content) + except Exception: + yield content + else: + self._debug(f"[WARN] Unknown message type: {message_type}") except Exception as e: # Clean up WebSocket connection errors error_msg = str(e) @@ -196,8 +218,28 @@ def run_stream(self, agent_id: str, entrypoint_tag: str, input_args, input_kwarg self._debug("Stream started") continue elif message_type == "data": - # Yield the actual chunk data - yield message.get("content") + content = message.get("content") + if content is None: + yield None + else: + if isinstance(content, str): + try: + yield self.serializer.deserialize_object_from_structured(content) + continue + except Exception: + pass + try: + yield self.serializer.deserialize_object(content) + continue + except Exception: + yield content + continue + try: + yield self.serializer.deserialize_object(content) + except Exception: + yield content + else: + self._debug(f"[WARN] Unknown message type: {message_type}") except Exception as e: # Clean up WebSocket connection errors error_msg = str(e) From 32c7ba07c5a57ba44533a9a9417aaffb1ca1d072 Mon Sep 17 00:00:00 2001 From: sawradip Date: Thu, 13 Nov 2025 04:50:42 +0600 Subject: [PATCH 2/3] feat: standardize response format across CLI, SDK, and clients - Updated `/run` responses to return a minimal structured output, aligning with the new payload contract. - Enhanced documentation in the CLI guide to reflect the simplified response format. - Introduced `AgentRunResponseMinimal` schema for consistent error handling and response structure across components. --- docs/cli/commands/run.mdx | 20 ++++ runagent-go/runagent/pkg/client/client.go | 54 ++++++++- .../runagent/src/client/runagent_client.rs | 12 +- runagent-ts/src/client/index.ts | 35 +++++- runagent-ts/src/serializer/index.ts | 22 ++++ runagent-ts/src/types/index.ts | 22 +++- runagent/client/client.py | 33 ++++-- runagent/sdk/server/local_server.py | 108 ++---------------- runagent/utils/schema.py | 11 ++ 9 files changed, 194 insertions(+), 123 deletions(-) diff --git a/docs/cli/commands/run.mdx b/docs/cli/commands/run.mdx index fc7cd3b..cb68028 100644 --- a/docs/cli/commands/run.mdx +++ b/docs/cli/commands/run.mdx @@ -58,6 +58,26 @@ The input must be valid JSON: } ``` +## Response Format + +The CLI and SDK now return a minimal payload when the execution completes: + +```json +{ + "success": true, + "data": "{\"type\": \"string\", \"payload\": \"...\"}", + "message": "Agent execution completed successfully", + "error": null, + "timestamp": "2025-11-12T22:23:35.216480", + "request_id": "adffa696-6273-4c5b-a933-883d830fd72c" +} +``` + +- `data` contains the agent output encoded with `serialize_object_to_structured`, so the CLI/SDK can deterministically decode every result type. +- Full execution metadata (runtime, VM, invocation ID, etc.) remains available through the local invocation history endpoints and the RunAgent dashboard/middleware. + +Error responses keep the same envelope but include an `error` object with diagnostic fields. + ## See Also - [`runagent deploy`](/cli/commands/deploy) - Deploy an agent first diff --git a/runagent-go/runagent/pkg/client/client.go b/runagent-go/runagent/pkg/client/client.go index 380eef4..4a373fe 100644 --- a/runagent-go/runagent/pkg/client/client.go +++ b/runagent-go/runagent/pkg/client/client.go @@ -7,6 +7,7 @@ import ( "fmt" "io" "net/http" + "strconv" "strings" "time" @@ -241,9 +242,23 @@ func (c *Client) Run(ctx context.Context, input map[string]interface{}) (interfa } } - // Return output_data if it exists, otherwise return the whole response + // Handle data field (simplified structured output or legacy execution payload) + if dataField, exists := response["data"]; exists { + switch data := dataField.(type) { + case string: + return c.serializer.DeserializeStructuredString(data), nil + case map[string]interface{}: + if resultData, ok := data["result_data"].(map[string]interface{}); ok { + if output, ok := resultData["data"]; ok { + return c.serializer.DeserializeObject(output, false), nil + } + } + } + } + + // Legacy fallback: return output_data if it exists if outputData, exists := response["output_data"]; exists { - return outputData, nil + return c.serializer.DeserializeObject(outputData, false), nil } return response, nil @@ -446,6 +461,38 @@ func NewCoreSerializer() *CoreSerializer { return &CoreSerializer{} } +// DeserializeStructuredString converts structured serializer output to native Go types +func (s *CoreSerializer) DeserializeStructuredString(structured string) interface{} { + var structuredMap map[string]interface{} + if err := json.Unmarshal([]byte(structured), &structuredMap); err != nil { + if unquoted, err2 := strconv.Unquote(structured); err2 == nil { + return unquoted + } + return structured + } + + payload, payloadExists := structuredMap["payload"] + if !payloadExists { + return structuredMap + } + + switch p := payload.(type) { + case string: + if len(p) > 0 { + var decoded interface{} + if err := json.Unmarshal([]byte(p), &decoded); err == nil { + return decoded + } + if unquoted, err := strconv.Unquote(p); err == nil { + return unquoted + } + } + return p + default: + return p + } +} + // SerializeMessage serializes a WebSocket message func (s *CoreSerializer) SerializeMessage(message WebSocketMessage) (string, error) { messageDict := map[string]interface{}{ @@ -504,5 +551,8 @@ func (s *CoreSerializer) DeserializeMessage(jsonStr string) (*WebSocketMessage, // DeserializeObject deserializes a JSON object func (s *CoreSerializer) DeserializeObject(jsonResp interface{}, reconstruct bool) interface{} { + if str, ok := jsonResp.(string); ok { + return s.DeserializeStructuredString(str) + } return jsonResp // Simple pass-through for now } diff --git a/runagent-rust/runagent/src/client/runagent_client.rs b/runagent-rust/runagent/src/client/runagent_client.rs index 3c3dbd0..857505d 100644 --- a/runagent-rust/runagent/src/client/runagent_client.rs +++ b/runagent-rust/runagent/src/client/runagent_client.rs @@ -243,8 +243,18 @@ impl RunAgentClient { .await?; if response.get("success").and_then(|s| s.as_bool()).unwrap_or(false) { - // Handle new response format with nested data (matching Python SDK) if let Some(data) = response.get("data") { + // Simplified payload: data is a structured output string + if let Some(data_str) = data.as_str() { + if let Ok(parsed) = serde_json::from_str::(data_str) { + return self.serializer.deserialize_object(parsed); + } + return self + .serializer + .deserialize_object(Value::String(data_str.to_string())); + } + + // Legacy detailed execution payload if let Some(result_data) = data.get("result_data") { if let Some(output_data) = result_data.get("data") { // Check if the output contains a generator object string diff --git a/runagent-ts/src/client/index.ts b/runagent-ts/src/client/index.ts index 5132358..6e1c82e 100644 --- a/runagent-ts/src/client/index.ts +++ b/runagent-ts/src/client/index.ts @@ -230,11 +230,38 @@ export class RunAgentClient { ); if (response.success !== false) { - const responseData = response.output_data; - return this.serializer.deserializeObject(responseData as JsonValue); - } else { - throw new Error(response.error || 'Agent execution failed'); + let payload: unknown = null; + + if (typeof response.data === 'string') { + payload = this.serializer.deserializeObject(response.data); + } else if ( + response.data && + typeof response.data === 'object' && + 'result_data' in (response.data as Record) + ) { + const resultData = (response.data as Record)['result_data']; + if ( + resultData && + typeof resultData === 'object' && + 'data' in (resultData as Record) + ) { + payload = this.serializer.deserializeObject( + (resultData as Record)['data'] as JsonValue + ); + } + } else if (response.output_data !== undefined) { + payload = this.serializer.deserializeObject(response.output_data as JsonValue); + } + + return payload ?? null; } + + const errorMessage = + typeof response.error === 'string' + ? response.error + : (response.error as { message?: string })?.message ?? 'Agent execution failed'; + + throw new Error(errorMessage); } private async *_runStream( diff --git a/runagent-ts/src/serializer/index.ts b/runagent-ts/src/serializer/index.ts index 4a02fc7..57eaea1 100644 --- a/runagent-ts/src/serializer/index.ts +++ b/runagent-ts/src/serializer/index.ts @@ -27,6 +27,28 @@ export class CoreSerializer { try { const deserializedData = typeof jsonResp === 'string' ? JSON.parse(jsonResp) : jsonResp; + if ( + deserializedData && + typeof deserializedData === 'object' && + deserializedData !== null && + 'type' in (deserializedData as Record) && + 'payload' in (deserializedData as Record) + ) { + const structured = deserializedData as { type?: string; payload?: unknown }; + const payload = structured.payload; + + if (typeof payload === 'string') { + try { + const parsedPayload = JSON.parse(payload); + return this._reconstructNestedJson(parsedPayload); + } catch { + return payload; + } + } + + return this._reconstructNestedJson(payload); + } + if (!reconstruct) { return this._reconstructNestedJson( (deserializedData as Record)?.content || deserializedData diff --git a/runagent-ts/src/types/index.ts b/runagent-ts/src/types/index.ts index 1008541..40148f4 100644 --- a/runagent-ts/src/types/index.ts +++ b/runagent-ts/src/types/index.ts @@ -10,12 +10,22 @@ export interface RunAgentConfig { apiPrefix?: string; } -export interface ApiResponse { - success: boolean; - output_data?: T; - error?: string; - data?: T; - } +export interface ApiResponse { + success: boolean; + data?: T; + output_data?: T; + error?: + | string + | { + code?: string; + message?: string; + details?: unknown; + field?: string | null; + }; + message?: string | null; + timestamp?: string | null; + request_id?: string | null; +} export interface WebSocketMessage { id: string; diff --git a/runagent/client/client.py b/runagent/client/client.py index bb47283..b3aa582 100644 --- a/runagent/client/client.py +++ b/runagent/client/client.py @@ -74,21 +74,30 @@ def run(self, *input_args, **input_kwargs): if os.getenv('DISABLE_TRY_CATCH'): print(f"response: {response}") if response.get("success"): - # Handle new response format with nested data - if "data" in response and "result_data" in response["data"]: - response_data = response["data"]["result_data"].get("data") - else: - # Fallback to old format for backward compatibility - response_data = response.get("output_data") + response_payload = None + + data_field = response.get("data") - if response_data is None: + # Legacy detailed execution payload + if isinstance(data_field, dict) and "result_data" in data_field: + response_payload = data_field["result_data"].get("data") + # Simplified payload: data is the structured output string + elif isinstance(data_field, str): + response_payload = data_field + # Backward compatibility for very old responses + elif "output_data" in response: + response_payload = response.get("output_data") + + if response_payload is None: return None - try: - return self.serializer.deserialize_object_from_structured(response_data) - except Exception: - # Backward compatibility with legacy plain JSON responses - return self.serializer.deserialize_object(response_data) + if isinstance(response_payload, str): + try: + return self.serializer.deserialize_object_from_structured(response_payload) + except Exception: + pass + + return self.serializer.deserialize_object(response_payload) else: # Handle new error format with ErrorDetail object diff --git a/runagent/sdk/server/local_server.py b/runagent/sdk/server/local_server.py index 7459808..5297812 100644 --- a/runagent/sdk/server/local_server.py +++ b/runagent/sdk/server/local_server.py @@ -20,7 +20,7 @@ from runagent.sdk.db import DBService from runagent.sdk.server.framework import get_executor from runagent.utils.agent import detect_framework, get_agent_config -from runagent.utils.schema import AgentInfo, AgentRunRequest, AgentRunResponse, AgentRunResponseV2, ExecutionData, ErrorDetail, WebSocketActionType, WebSocketAgentRequest +from runagent.utils.schema import AgentInfo, AgentRunRequest, AgentRunResponseMinimal, ErrorDetail, WebSocketActionType, WebSocketAgentRequest from runagent.utils.imports import PackageImporter from runagent.utils.schema import MessageType from runagent.sdk.server.socket_utils import AgentWebSocketHandler @@ -667,10 +667,10 @@ async def run_agent_stream(websocket: WebSocket, agent_id: str = self.agent_id): @self.app.exception_handler(HTTPException) async def http_exception_handler(request, exc): - """Convert HTTPException to the new error format""" + """Convert HTTPException to the simplified error format""" return JSONResponse( status_code=exc.status_code, - content=AgentRunResponseV2( + content=AgentRunResponseMinimal( success=False, data=None, message=None, @@ -687,10 +687,10 @@ async def http_exception_handler(request, exc): @self.app.exception_handler(Exception) async def general_exception_handler(request, exc): - """Convert general exceptions to the new error format""" + """Convert general exceptions to the simplified error format""" return JSONResponse( status_code=500, - content=AgentRunResponseV2( + content=AgentRunResponseMinimal( success=False, data=None, message=None, @@ -707,7 +707,7 @@ async def general_exception_handler(request, exc): @self.app.post( f"/api/v1/agents/{self.agent_id}/run", - response_model=AgentRunResponseV2 + response_model=AgentRunResponseMinimal ) # (self.create_endpoint_handler_with_tracking(runner, self.agent_id, entrypoint.tag)) async def run_agent(request: AgentRunRequest): @@ -751,7 +751,7 @@ async def run_agent(request: AgentRunRequest): error_detail = None result_data = None serializable_output = None - middleware_synced = False + try: console.print(f"Running agent: {self.agent_id} (invocation: {invocation_id}...)") @@ -853,7 +853,6 @@ async def run_agent(request: AgentRunRequest): if sync_result: console.print(f"✅ [green]Execution synced to middleware successfully[/green]") - middleware_synced = True else: console.print(f"⚠️ [yellow]Middleware sync returned False[/yellow]") @@ -884,58 +883,9 @@ async def run_agent(request: AgentRunRequest): f"{execution_time:.2f}s (invocation: {invocation_id}...)" ) - # Create execution data for the new response format - execution_data = ExecutionData( - execution_id=invocation_id, - agent_id=self.agent_id, - user_id=None, - deployment_id=None, - entrypoint_id=request.entrypoint_tag, - status="completed", - started_at=datetime.fromtimestamp(start_time).isoformat(), - completed_at=datetime.now().isoformat(), - runtime_seconds=execution_time, - input_data={ - "input_args": request.input_args, - "input_kwargs": request.input_kwargs - }, - result_data={ - "message": "", - "data": structured_output_json, - "vm_id": str(uuid.uuid4()), - "type": "result", - "timestamp": datetime.now().isoformat() - }, - execution_metadata={ - "entrypoint_tag": request.entrypoint_tag, - "project_id": None, - "deployment_id": None, - "timeout_seconds": 60, - "async_execution": False, - "execution_config": {}, - "middleware_synced": middleware_synced - }, - error_message=None, - is_local=True, - agent_name=self.agent_name, - project_id=None, - project_name=None, - endpoint=None, - priority="normal", + return AgentRunResponseMinimal( success=True, - result={ - "message": "", - "data": structured_output_json, - "vm_id": str(uuid.uuid4()), - "type": "result", - "timestamp": datetime.now().isoformat() - }, - error=None - ) - - return AgentRunResponseV2( - success=True, - data=execution_data, + data=structured_output_json, message="Agent execution completed successfully", error=None, timestamp=datetime.now().isoformat(), @@ -1004,7 +954,6 @@ async def run_agent(request: AgentRunRequest): if sync_result: console.print(f"✅ [green]Failed execution synced to middleware[/green]") - middleware_synced = True else: console.print(f"⚠️ [yellow]Middleware sync returned False[/yellow]") @@ -1033,44 +982,7 @@ async def run_agent(request: AgentRunRequest): console.print(f"{error_detail} (invocation: {invocation_id[:8]}...)") - # Create execution data for the new response format (error case) - execution_data = ExecutionData( - execution_id=invocation_id, - agent_id=self.agent_id, - user_id=None, - deployment_id=None, - entrypoint_id=request.entrypoint_tag, - status="failed", - started_at=datetime.fromtimestamp(start_time).isoformat(), - completed_at=datetime.now().isoformat(), - runtime_seconds=execution_time, - input_data={ - "input_args": request.input_args, - "input_kwargs": request.input_kwargs - }, - result_data=None, - execution_metadata={ - "entrypoint_tag": request.entrypoint_tag, - "project_id": None, - "deployment_id": None, - "timeout_seconds": 60, - "async_execution": False, - "execution_config": {}, - "middleware_synced": middleware_synced - }, - error_message=error_detail, - is_local=True, - agent_name=self.agent_name, - project_id=None, - project_name=None, - endpoint=None, - priority="normal", - success=False, - result=None, - error=error_detail - ) - - return AgentRunResponseV2( + return AgentRunResponseMinimal( success=False, data=None, message=None, diff --git a/runagent/utils/schema.py b/runagent/utils/schema.py index a3c204a..6776e5a 100644 --- a/runagent/utils/schema.py +++ b/runagent/utils/schema.py @@ -223,6 +223,17 @@ class AgentRunResponseV2(BaseModel): request_id: str +class AgentRunResponseMinimal(BaseModel): + """Simplified response model for agent execution returning structured output""" + + success: bool + data: t.Optional[str] = None + message: t.Optional[str] = None + error: t.Optional[ErrorDetail] = None + timestamp: str + request_id: str + + class AgentInfo(BaseModel): """Agent information and endpoints""" From ac455ad83182039e2fca9ae9ffb8a34a0b6e6709 Mon Sep 17 00:00:00 2001 From: sawradip Date: Thu, 13 Nov 2025 04:51:42 +0600 Subject: [PATCH 3/3] chore: bump version to v0.1.26 - Updated all SDK versions to 0.1.26 - Generated changelog with git-cliff --- CHANGELOG.md | 60 ++++++++----------------------- pyproject.toml | 6 ++-- runagent-go/runagent/version.go | 2 +- runagent-rust/runagent/Cargo.toml | 2 +- runagent-ts/package-lock.json | 4 +-- runagent-ts/package.json | 2 +- runagent/__init__.py | 2 +- runagent/__version__.py | 2 +- 8 files changed, 25 insertions(+), 55 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a3a838e..aa56d37 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,59 +1,29 @@ # Changelog All notable changes to this project's latest version. -## [0.1.24] - 2025-11-06 +## [0.1.25] - 2025-11-12 ### Bug Fixes -- Fixed examples on run cmd -- Init command fixing wip - -### Documentation - -- Sdk folder removed -- Added explanation folder -- Removed example folder -- Removed frameworks folder -- Removed get started folder -- Added how to folder -- Added resources folder -- Added new snippet -- Added tutorials -- Added reference -- Added new api reference -- Added cli overview -- Added new docs.json +- Added agent ID to all templates json ([#76](https://github.com/your-org/your-repo/issues/76)) +- Add shorthand option for confirmation skip in teardown command +- Update console output formatting for extra parameters in run and run_stream commands ### Features -- Removed deploy-local command -- Deploy-local fully removed -- Updated same upload_agent function names -- Fingerprint feature added back to db -- Added git validation & efficient connectivity check -- Agent run cli working for remote+local -- Run-stream working locally, proper json format. -- Improved langgarph default template -- URL prefix working > rest+socket -- Debug option fixed -- Auth test fixed with updated endpoint -- Runagent deploy working -- Moved user_data json ro sqlite db approach -- Init coomand interactive -- Fixed & improved template downloading -- Split cli cmds into seperate files -- Express login [device-browser code flow] added -- Persistent agent id working -- Cleaned emojis form output -- Added whoami command -- Standardized local agent execution logging -- Auto rewload suported in local server -- Removed replacing agent id -- Muted db replace agent option -- Improved debug log +- Removed capacity tracking of local agents +- Improve init message +- Enhance error handling and suggestions in deployment and upload commands +- Enhanced init command +- Update deployment and initialization to include dashboard URLs and enhance agent configuration +- Add structured serialization and deserialization methods to CoreSerializer ### Miscellaneous Tasks -- Bump version to v0.1.24 +- Bump version to v0.1.25 + +### Refactor + +- Improve error handling and messaging in WebSocket and REST client diff --git a/pyproject.toml b/pyproject.toml index 32bd242..b442798 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "hatchling.build" [project] name = "runagent" -version = "0.1.25" +version = "0.1.26" description = "A command-line tool and SDK for deploying, managing, and interacting with AI agents" readme = "README.md" requires-python = ">=3.9" @@ -103,7 +103,7 @@ line_length = 88 skip = ["docs"] [tool.mypy] -python_version = "0.1.25" +python_version = "0.1.26" warn_return_any = true warn_unused_configs = true disallow_untyped_defs = true @@ -159,7 +159,7 @@ fail_under = 80 [tool.ruff] line-length = 88 -target-version = "0.1.25" +target-version = "0.1.26" select = [ "E", # pycodestyle errors "W", # pycodestyle warnings diff --git a/runagent-go/runagent/version.go b/runagent-go/runagent/version.go index d9dd96b..760a003 100644 --- a/runagent-go/runagent/version.go +++ b/runagent-go/runagent/version.go @@ -1,4 +1,4 @@ package runagent // Version represents the current version of the RunAgent Go SDK -const Version = "0.1.25" +const Version = "0.1.26" diff --git a/runagent-rust/runagent/Cargo.toml b/runagent-rust/runagent/Cargo.toml index 215f818..ede2641 100644 --- a/runagent-rust/runagent/Cargo.toml +++ b/runagent-rust/runagent/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "runagent" -version = "0.1.25" +version = "0.1.26" edition = "2021" description = "RunAgent SDK for Rust - Client SDK for interacting with deployed AI agents" license = "MIT" diff --git a/runagent-ts/package-lock.json b/runagent-ts/package-lock.json index a7a9e5f..4e5924c 100644 --- a/runagent-ts/package-lock.json +++ b/runagent-ts/package-lock.json @@ -1,12 +1,12 @@ { "name": "runagent", - "version": "0.1.25", + "version": "0.1.26", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "runagent", - "version": "0.1.25", + "version": "0.1.26", "dependencies": { "better-sqlite3": "^12.2.0" }, diff --git a/runagent-ts/package.json b/runagent-ts/package.json index 8f31ef2..45d1929 100644 --- a/runagent-ts/package.json +++ b/runagent-ts/package.json @@ -1,6 +1,6 @@ { "name": "runagent", - "version": "0.1.25", + "version": "0.1.26", "type": "module", "files": [ "dist" diff --git a/runagent/__init__.py b/runagent/__init__.py index 20aff99..e16f10b 100644 --- a/runagent/__init__.py +++ b/runagent/__init__.py @@ -5,7 +5,7 @@ built with frameworks like LangGraph, LangChain, and LlamaIndex. """ -__version__ = "0.1.25" +__version__ = "0.1.26" from .client import RunAgentClient diff --git a/runagent/__version__.py b/runagent/__version__.py index 43a0e4e..c8ec146 100644 --- a/runagent/__version__.py +++ b/runagent/__version__.py @@ -1 +1 @@ -__version__ = "0.1.25" +__version__ = "0.1.26"