skyvern-llamaindex 0.0.2__tar.gz → 0.0.3__tar.gz

{skyvern_llamaindex-0.0.2 → skyvern_llamaindex-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skyvern-llamaindex
-Version: 0.0.2
+Version: 0.0.3
 Summary: Skyvern integration for LlamaIndex
 Author: lawyzheng
 Author-email: lawy@skyvern.com
@@ -48,14 +48,14 @@ import asyncio
 from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
-from skyvern_llamaindex.agent import SkyvernToolSpec
+from skyvern_llamaindex.agent import SkyvernTaskToolSpec
 
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_tool = SkyvernToolSpec()
+skyvern_tool = SkyvernTaskToolSpec()
 
-tools = skyvern_tool.to_tool_list(["run_task"])
+tools = skyvern_tool.to_tool_list(["run"])
 
 agent = OpenAIAgent.from_tools(
     tools=tools,
@@ -70,7 +70,7 @@ print(response)
 ```
 
 ### Dispatch a task(async) with skyvern agent (calling skyvern agent function directly in the tool)
-> dispatch task will return immediately and the task will be running in the background. You can use `get_task` tool to poll the task information until the task is finished.
+> dispatch task will return immediately and the task will be running in the background. You can use `get` tool to poll the task information until the task is finished.
 
 :warning: :warning: if you want to run this code block, you need to run `skyvern init --openai-api-key <your_openai_api_key>` command in your terminal to set up skyvern first.
 
@@ -80,7 +80,7 @@ from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
 from llama_index.core.tools import FunctionTool
-from skyvern_llamaindex.agent import SkyvernToolSpec
+from skyvern_llamaindex.agent import SkyvernTaskToolSpec
 
 async def sleep(seconds: int) -> str:
     await asyncio.sleep(seconds)
@@ -89,7 +89,7 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_tool = SkyvernToolSpec()
+skyvern_tool = SkyvernTaskToolSpec()
 
 sleep_tool = FunctionTool.from_defaults(
     async_fn=sleep,
@@ -97,7 +97,7 @@ sleep_tool = FunctionTool.from_defaults(
     name="sleep",
 )
 
-tools = skyvern_tool.to_tool_list(["dispatch_task", "get_task"])
+tools = skyvern_tool.to_tool_list(["dispatch", "get"])
 tools.append(sleep_tool)
 
 agent = OpenAIAgent.from_tools(
@@ -122,7 +122,7 @@ import asyncio
 from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
-from skyvern_llamaindex.client import SkyvernToolSpec
+from skyvern_llamaindex.client import SkyvernTaskToolSpec
 
 
 async def sleep(seconds: int) -> str:
@@ -132,11 +132,11 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_client_tool = SkyvernToolSpec(
+skyvern_client_tool = SkyvernTaskToolSpec(
     credential="<your_organization_api_key>",
 )
 
-tools = skyvern_client_tool.to_tool_list(["run_task"])
+tools = skyvern_client_tool.to_tool_list(["run"])
 
 agent = OpenAIAgent.from_tools(
     tools=tools,
@@ -151,7 +151,7 @@ print(response)
 ```
 
 ### Dispatch a task(async) with skyvern client (calling skyvern OpenAPI in the tool)
-> dispatch task will return immediately and the task will be running in the background. You can use `get_task` tool to poll the task information until the task is finished.
+> dispatch task will return immediately and the task will be running in the background. You can use `get` tool to poll the task information until the task is finished.
 
 no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
 
@@ -161,7 +161,7 @@ from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
 from llama_index.core.tools import FunctionTool
-from skyvern_llamaindex.client import SkyvernToolSpec
+from skyvern_llamaindex.client import SkyvernTaskToolSpec
 
 
 async def sleep(seconds: int) -> str:
@@ -171,7 +171,7 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_client_tool = SkyvernToolSpec(
+skyvern_client_tool = SkyvernTaskToolSpec(
     credential="<your_organization_api_key>",
 )
 
@@ -181,7 +181,7 @@ sleep_tool = FunctionTool.from_defaults(
     name="sleep",
 )
 
-tools = skyvern_client_tool.to_tool_list(["dispatch_task", "get_task"])
+tools = skyvern_client_tool.to_tool_list(["dispatch", "get"])
 tools.append(sleep_tool)
 
 agent = OpenAIAgent.from_tools(

{skyvern_llamaindex-0.0.2 → skyvern_llamaindex-0.0.3}/README.md

@@ -35,14 +35,14 @@ import asyncio
 from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
-from skyvern_llamaindex.agent import SkyvernToolSpec
+from skyvern_llamaindex.agent import SkyvernTaskToolSpec
 
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_tool = SkyvernToolSpec()
+skyvern_tool = SkyvernTaskToolSpec()
 
-tools = skyvern_tool.to_tool_list(["run_task"])
+tools = skyvern_tool.to_tool_list(["run"])
 
 agent = OpenAIAgent.from_tools(
     tools=tools,
@@ -57,7 +57,7 @@ print(response)
 ```
 
 ### Dispatch a task(async) with skyvern agent (calling skyvern agent function directly in the tool)
-> dispatch task will return immediately and the task will be running in the background. You can use `get_task` tool to poll the task information until the task is finished.
+> dispatch task will return immediately and the task will be running in the background. You can use `get` tool to poll the task information until the task is finished.
 
 :warning: :warning: if you want to run this code block, you need to run `skyvern init --openai-api-key <your_openai_api_key>` command in your terminal to set up skyvern first.
 
@@ -67,7 +67,7 @@ from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
 from llama_index.core.tools import FunctionTool
-from skyvern_llamaindex.agent import SkyvernToolSpec
+from skyvern_llamaindex.agent import SkyvernTaskToolSpec
 
 async def sleep(seconds: int) -> str:
     await asyncio.sleep(seconds)
@@ -76,7 +76,7 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_tool = SkyvernToolSpec()
+skyvern_tool = SkyvernTaskToolSpec()
 
 sleep_tool = FunctionTool.from_defaults(
     async_fn=sleep,
@@ -84,7 +84,7 @@ sleep_tool = FunctionTool.from_defaults(
     name="sleep",
 )
 
-tools = skyvern_tool.to_tool_list(["dispatch_task", "get_task"])
+tools = skyvern_tool.to_tool_list(["dispatch", "get"])
 tools.append(sleep_tool)
 
 agent = OpenAIAgent.from_tools(
@@ -109,7 +109,7 @@ import asyncio
 from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
-from skyvern_llamaindex.client import SkyvernToolSpec
+from skyvern_llamaindex.client import SkyvernTaskToolSpec
 
 
 async def sleep(seconds: int) -> str:
@@ -119,11 +119,11 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_client_tool = SkyvernToolSpec(
+skyvern_client_tool = SkyvernTaskToolSpec(
     credential="<your_organization_api_key>",
 )
 
-tools = skyvern_client_tool.to_tool_list(["run_task"])
+tools = skyvern_client_tool.to_tool_list(["run"])
 
 agent = OpenAIAgent.from_tools(
     tools=tools,
@@ -138,7 +138,7 @@ print(response)
 ```
 
 ### Dispatch a task(async) with skyvern client (calling skyvern OpenAPI in the tool)
-> dispatch task will return immediately and the task will be running in the background. You can use `get_task` tool to poll the task information until the task is finished.
+> dispatch task will return immediately and the task will be running in the background. You can use `get` tool to poll the task information until the task is finished.
 
 no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
 
@@ -148,7 +148,7 @@ from dotenv import load_dotenv
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.llms.openai import OpenAI
 from llama_index.core.tools import FunctionTool
-from skyvern_llamaindex.client import SkyvernToolSpec
+from skyvern_llamaindex.client import SkyvernTaskToolSpec
 
 
 async def sleep(seconds: int) -> str:
@@ -158,7 +158,7 @@ async def sleep(seconds: int) -> str:
 # load OpenAI API key from .env
 load_dotenv()
 
-skyvern_client_tool = SkyvernToolSpec(
+skyvern_client_tool = SkyvernTaskToolSpec(
     credential="<your_organization_api_key>",
 )
 
@@ -168,7 +168,7 @@ sleep_tool = FunctionTool.from_defaults(
     name="sleep",
 )
 
-tools = skyvern_client_tool.to_tool_list(["dispatch_task", "get_task"])
+tools = skyvern_client_tool.to_tool_list(["dispatch", "get"])
 tools.append(sleep_tool)
 
 agent = OpenAIAgent.from_tools(

{skyvern_llamaindex-0.0.2 → skyvern_llamaindex-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "skyvern-llamaindex"
-version = "0.0.2"
+version = "0.0.3"
 description = "Skyvern integration for LlamaIndex"
 authors = ["lawyzheng <lawy@skyvern.com>"]
 packages = [{ include = "skyvern_llamaindex" }]

{skyvern_llamaindex-0.0.2 → skyvern_llamaindex-0.0.3}/skyvern_llamaindex/agent.py

@@ -9,42 +9,42 @@ from skyvern.forge.sdk.schemas.observers import ObserverTask
 from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskResponse
 
 
-class SkyvernToolSpec(BaseToolSpec):
+class SkyvernTaskToolSpec(BaseToolSpec):
     spec_functions: List[SPEC_FUNCTION_TYPE] = [
-        "run_task",
-        "dispatch_task",
-        "get_task",
+        "run",
+        "dispatch",
+        "get",
     ]
     spec_metadata: Dict[str, Dict[str, ToolMetadata]] = {
         "TaskV1": {
-            "run_task": ToolMetadata(
+            "run": ToolMetadata(
                 name="run-skyvern-agent-task",
                 description="Use Skyvern agent to run a task. This function won't return until the task is finished.",
                 fn_schema=TaskV1Request,
             ),
-            "dispatch_task": ToolMetadata(
+            "dispatch": ToolMetadata(
                 name="dispatch-skyvern-agent-task",
                 description="Use Skyvern agent to dispatch a task. This function will return immediately and the task will be running in the background.",
                 fn_schema=TaskV1Request,
             ),
-            "get_task": ToolMetadata(
+            "get": ToolMetadata(
                 name="get-skyvern-agent-task",
                 description="Use Skyvern agent to get a task.",
                 fn_schema=GetTaskInput,
             ),
         },
         "TaskV2": {
-            "run_task": ToolMetadata(
+            "run": ToolMetadata(
                 name="run-skyvern-agent-task",
                 description="Use Skyvern agent to run a task. This function won't return until the task is finished.",
                 fn_schema=TaskV2Request,
             ),
-            "dispatch_task": ToolMetadata(
+            "dispatch": ToolMetadata(
                 name="dispatch-skyvern-agent-task",
                 description="Use Skyvern agent to dispatch a task. This function will return immediately and the task will be running in the background.",
                 fn_schema=TaskV2Request,
             ),
-            "get_task": ToolMetadata(
+            "get": ToolMetadata(
                 name="get-skyvern-agent-task",
                 description="Use Skyvern agent to get a task.",
                 fn_schema=GetTaskInput,
@@ -66,19 +66,19 @@ class SkyvernToolSpec(BaseToolSpec):
 
         return self.spec_metadata.get(self.engine, {}).get(fn_name)
 
-    async def run_task(self, **kwargs: Dict[str, Any]) -> TaskResponse | ObserverTask:
+    async def run(self, **kwargs: Dict[str, Any]) -> TaskResponse | ObserverTask:
         if self.engine == "TaskV1":
             return await self.run_task_v1(**kwargs)
         else:
             return await self.run_task_v2(**kwargs)
 
-    async def dispatch_task(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | ObserverTask:
+    async def dispatch(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | ObserverTask:
         if self.engine == "TaskV1":
             return await self.dispatch_task_v1(**kwargs)
         else:
             return await self.dispatch_task_v2(**kwargs)
 
-    async def get_task(self, task_id: str) -> TaskResponse | ObserverTask | None:
+    async def get(self, task_id: str) -> TaskResponse | ObserverTask | None:
         if self.engine == "TaskV1":
             return await self.get_task_v1(task_id)
         else:

{skyvern_llamaindex-0.0.2 → skyvern_llamaindex-0.0.3}/skyvern_llamaindex/client.py

@@ -9,43 +9,43 @@ from skyvern.client import AsyncSkyvern
 from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskResponse
 
 
-class SkyvernToolSpec(BaseToolSpec):
+class SkyvernTaskToolSpec(BaseToolSpec):
     spec_functions: List[SPEC_FUNCTION_TYPE] = [
-        "run_task",
-        "dispatch_task",
-        "get_task",
+        "run",
+        "dispatch",
+        "get",
     ]
 
     spec_metadata: Dict[str, Dict[str, ToolMetadata]] = {
         "TaskV1": {
-            "run_task": ToolMetadata(
+            "run": ToolMetadata(
                 name="run-skyvern-client-task",
                 description="Use Skyvern client to run a task. This function won't return until the task is finished.",
                 fn_schema=TaskV1Request,
             ),
-            "dispatch_task": ToolMetadata(
+            "dispatch": ToolMetadata(
                 name="dispatch-skyvern-client-task",
                 description="Use Skyvern client to dispatch a task. This function will return immediately and the task will be running in the background.",
                 fn_schema=TaskV1Request,
             ),
-            "get_task": ToolMetadata(
+            "get": ToolMetadata(
                 name="get-skyvern-client-task",
                 description="Use Skyvern client to get a task.",
                 fn_schema=GetTaskInput,
             ),
         },
         "TaskV2": {
-            "run_task": ToolMetadata(
+            "run": ToolMetadata(
                 name="run-skyvern-client-task",
                 description="Use Skyvern client to run a task. This function won't return until the task is finished.",
                 fn_schema=TaskV2Request,
             ),
-            "dispatch_task": ToolMetadata(
+            "dispatch": ToolMetadata(
                 name="dispatch-skyvern-client-task",
                 description="Use Skyvern client to dispatch a task. This function will return immediately and the task will be running in the background.",
                 fn_schema=TaskV2Request,
             ),
-            "get_task": ToolMetadata(
+            "get": ToolMetadata(
                 name="get-skyvern-client-task",
                 description="Use Skyvern client to get a task.",
                 fn_schema=GetTaskInput,
@@ -79,19 +79,19 @@ class SkyvernToolSpec(BaseToolSpec):
 
         return self.spec_metadata.get(self.engine, {}).get(fn_name)
 
-    async def run_task(self, **kwargs: Dict[str, Any]) -> TaskResponse | Dict[str, Any | None]:
+    async def run(self, **kwargs: Dict[str, Any]) -> TaskResponse | Dict[str, Any | None]:
         if self.engine == "TaskV1":
             return await self.run_task_v1(**kwargs)
         else:
             return await self.run_task_v2(**kwargs)
 
-    async def dispatch_task(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | Dict[str, Any | None]:
+    async def dispatch(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | Dict[str, Any | None]:
         if self.engine == "TaskV1":
             return await self.dispatch_task_v1(**kwargs)
         else:
             return await self.dispatch_task_v2(**kwargs)
 
-    async def get_task(self, task_id: str) -> TaskResponse | Dict[str, Any | None]:
+    async def get(self, task_id: str) -> TaskResponse | Dict[str, Any | None]:
         if self.engine == "TaskV1":
             return await self.get_task_v1(task_id)
         else: