skyvern-llamaindex 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

skyvern_llamaindex/agent.py

@@ -1,108 +1,132 @@
-from typing import Any, Dict, List, Literal, Tuple
+from typing import List, Literal, Optional
 
+from llama_index.core.tools import FunctionTool
 from llama_index.core.tools.tool_spec.base import SPEC_FUNCTION_TYPE, BaseToolSpec
-from llama_index.core.tools.types import ToolMetadata
-from skyvern_llamaindex.schema import GetTaskInput, TaskV1Request, TaskV2Request
+from skyvern_llamaindex.settings import settings
 
 from skyvern.agent import Agent
-from skyvern.forge.sdk.schemas.observers import ObserverTask
-from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskResponse
+from skyvern.forge import app
+from skyvern.forge.prompts import prompt_engine
+from skyvern.forge.sdk.schemas.observers import ObserverTask, ObserverTaskRequest
+from skyvern.forge.sdk.schemas.task_generations import TaskGenerationBase
+from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskRequest, TaskResponse
+
+default_agent = Agent()
+
+
+class SkyvernTool:
+    def __init__(self, agent: Optional[Agent] = None):
+        if agent is None:
+            agent = default_agent
+        self.agent = agent
+
+    def run_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(agent=self.agent)
+        return task_tool_spec.to_tool_list(["run_task"])[0]
+
+    def dispatch_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(agent=self.agent)
+        return task_tool_spec.to_tool_list(["dispatch_task"])[0]
+
+    def get_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(agent=self.agent)
+        return task_tool_spec.to_tool_list(["get_task"])[0]
 
 
 class SkyvernTaskToolSpec(BaseToolSpec):
     spec_functions: List[SPEC_FUNCTION_TYPE] = [
-        "run",
-        "dispatch",
-        "get",
+        "run_task",
+        "dispatch_task",
+        "get_task",
     ]
-    spec_metadata: Dict[str, Dict[str, ToolMetadata]] = {
-        "TaskV1": {
-            "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": 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": ToolMetadata(
-                name="get-skyvern-agent-task",
-                description="Use Skyvern agent to get a task.",
-                fn_schema=GetTaskInput,
-            ),
-        },
-        "TaskV2": {
-            "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": 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": ToolMetadata(
-                name="get-skyvern-agent-task",
-                description="Use Skyvern agent to get a task.",
-                fn_schema=GetTaskInput,
-            ),
-        },
-    }
-
-    def __init__(self, *, engine: Literal["TaskV1", "TaskV2"] = "TaskV2") -> None:
-        self.agent = Agent()
+
+    def __init__(
+        self,
+        *,
+        agent: Optional[Agent] = None,
+        engine: Literal["TaskV1", "TaskV2"] = settings.engine,
+        run_task_timeout_seconds: int = settings.run_task_timeout_seconds,
+    ) -> None:
+        if agent is None:
+            agent = Agent()
+        self.agent = agent
         self.engine = engine
+        self.run_task_timeout_seconds = run_task_timeout_seconds
 
-    def get_metadata_from_fn_name(
-        self, fn_name: str, spec_functions: List[str | Tuple[str, str]] | None = None
-    ) -> ToolMetadata | None:
-        try:
-            getattr(self, fn_name)
-        except AttributeError:
-            return None
+    # TODO: agent haven't exposed the task v1 generate function, we can migrate to use agent interface when it's available
+    async def _generate_v1_task_request(self, user_prompt: str) -> TaskGenerationBase:
+        llm_prompt = prompt_engine.load_prompt("generate-task", user_prompt=user_prompt)
+        llm_response = await app.LLM_API_HANDLER(prompt=llm_prompt, prompt_name="generate-task")
+        return TaskGenerationBase.model_validate(llm_response)
 
-        return self.spec_metadata.get(self.engine, {}).get(fn_name)
+    async def run_task(self, user_prompt: str, url: Optional[str] = None) -> TaskResponse | ObserverTask:
+        """
+        Use Skyvern agent to run a task. This function won't return until the task is finished.
+
+        Args:
+            user_prompt[str]: The user's prompt describing the task.
+            url (Optional[str]): The URL of the target website for the task.
+        """
 
-    async def run(self, **kwargs: Dict[str, Any]) -> TaskResponse | ObserverTask:
         if self.engine == "TaskV1":
-            return await self.run_task_v1(**kwargs)
+            return await self.run_task_v1(user_prompt=user_prompt, url=url)
         else:
-            return await self.run_task_v2(**kwargs)
+            return await self.run_task_v2(user_prompt=user_prompt, url=url)
+
+    async def dispatch_task(self, user_prompt: str, url: Optional[str] = None) -> CreateTaskResponse | ObserverTask:
+        """
+        Use Skyvern agent to dispatch a task. This function will return immediately and the task will be running in the background.
+
+        Args:
+            user_prompt[str]: The user's prompt describing the task.
+            url (Optional[str]): The URL of the target website for the task.
+        """
 
-    async def dispatch(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | ObserverTask:
         if self.engine == "TaskV1":
-            return await self.dispatch_task_v1(**kwargs)
+            return await self.dispatch_task_v1(user_prompt=user_prompt, url=url)
         else:
-            return await self.dispatch_task_v2(**kwargs)
+            return await self.dispatch_task_v2(user_prompt=user_prompt, url=url)
+
+    async def get_task(self, task_id: str) -> TaskResponse | ObserverTask | None:
+        """
+        Use Skyvern agent to get a task.
+
+        Args:
+            task_id[str]: The id of the task.
+        """
 
-    async def get(self, task_id: str) -> TaskResponse | ObserverTask | None:
         if self.engine == "TaskV1":
             return await self.get_task_v1(task_id)
         else:
             return await self.get_task_v2(task_id)
 
-    async def run_task_v1(self, **kwargs: Dict[str, Any]) -> TaskResponse:
-        task_request = TaskV1Request(**kwargs)
-        return await self.agent.run_task(task_request=task_request, timeout_seconds=task_request.timeout_seconds)
+    async def run_task_v1(self, user_prompt: str, url: Optional[str] = None) -> TaskResponse:
+        task_generation = await self._generate_v1_task_request(user_prompt=user_prompt)
+        task_request = TaskRequest.model_validate(task_generation, from_attributes=True)
+        if url is not None:
+            task_request.url = url
+
+        return await self.agent.run_task(task_request=task_request, timeout_seconds=self.run_task_timeout_seconds)
+
+    async def dispatch_task_v1(self, user_prompt: str, url: Optional[str] = None) -> CreateTaskResponse:
+        task_generation = await self._generate_v1_task_request(user_prompt=user_prompt)
+        task_request = TaskRequest.model_validate(task_generation, from_attributes=True)
+        if url is not None:
+            task_request.url = url
 
-    async def dispatch_task_v1(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse:
-        task_request = TaskV1Request(**kwargs)
         return await self.agent.create_task(task_request=task_request)
 
     async def get_task_v1(self, task_id: str) -> TaskResponse | None:
         return await self.agent.get_task(task_id=task_id)
 
-    async def run_task_v2(self, **kwargs: Dict[str, Any]) -> ObserverTask:
-        task_request = TaskV2Request(**kwargs)
+    async def run_task_v2(self, user_prompt: str, url: Optional[str] = None) -> ObserverTask:
+        task_request = ObserverTaskRequest(user_prompt=user_prompt, url=url)
         return await self.agent.run_observer_task_v_2(
-            task_request=task_request, timeout_seconds=task_request.timeout_seconds
+            task_request=task_request, timeout_seconds=self.run_task_timeout_seconds
         )
 
-    async def dispatch_task_v2(self, **kwargs: Dict[str, Any]) -> ObserverTask:
-        task_request = TaskV2Request(**kwargs)
+    async def dispatch_task_v2(self, user_prompt: str, url: Optional[str] = None) -> ObserverTask:
+        task_request = ObserverTaskRequest(user_prompt=user_prompt, url=url)
         return await self.agent.observer_task_v_2(task_request=task_request)
 
     async def get_task_v2(self, task_id: str) -> ObserverTask | None:

skyvern_llamaindex/client.py

@@ -1,171 +1,172 @@
-from typing import Any, Dict, List, Literal, Tuple
+from typing import Any, Dict, List, Literal, Optional
 
 from httpx import AsyncClient
+from llama_index.core.tools import FunctionTool
 from llama_index.core.tools.tool_spec.base import SPEC_FUNCTION_TYPE, BaseToolSpec
-from llama_index.core.tools.types import ToolMetadata
-from skyvern_llamaindex.schema import GetTaskInput, TaskV1Request, TaskV2Request
+from pydantic import BaseModel
+from skyvern_llamaindex.settings import settings
 
 from skyvern.client import AsyncSkyvern
-from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskResponse
+from skyvern.forge.sdk.schemas.observers import ObserverTaskRequest
+from skyvern.forge.sdk.schemas.tasks import CreateTaskResponse, TaskRequest, TaskResponse
+
+
+class SkyvernTool(BaseModel):
+    api_key: str = settings.api_key
+    base_url: str = settings.base_url
+
+    def run_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(
+            api_key=self.api_key,
+            base_url=self.base_url,
+        )
+
+        return task_tool_spec.to_tool_list(["run_task"])[0]
+
+    def dispatch_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(
+            api_key=self.api_key,
+            base_url=self.base_url,
+        )
+
+        return task_tool_spec.to_tool_list(["dispatch_task"])[0]
+
+    def get_task(self) -> FunctionTool:
+        task_tool_spec = SkyvernTaskToolSpec(
+            api_key=self.api_key,
+            base_url=self.base_url,
+        )
+
+        return task_tool_spec.to_tool_list(["get_task"])[0]
 
 
 class SkyvernTaskToolSpec(BaseToolSpec):
     spec_functions: List[SPEC_FUNCTION_TYPE] = [
-        "run",
-        "dispatch",
-        "get",
+        "run_task",
+        "dispatch_task",
+        "get_task",
     ]
 
-    spec_metadata: Dict[str, Dict[str, ToolMetadata]] = {
-        "TaskV1": {
-            "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": 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": ToolMetadata(
-                name="get-skyvern-client-task",
-                description="Use Skyvern client to get a task.",
-                fn_schema=GetTaskInput,
-            ),
-        },
-        "TaskV2": {
-            "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": 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": ToolMetadata(
-                name="get-skyvern-client-task",
-                description="Use Skyvern client to get a task.",
-                fn_schema=GetTaskInput,
-            ),
-        },
-    }
-
     def __init__(
         self,
-        credential: str,
         *,
-        base_url: str = "https://api.skyvern.com",
-        engine: Literal["TaskV1", "TaskV2"] = "TaskV2",
+        api_key: str = settings.api_key,
+        base_url: str = settings.base_url,
+        engine: Literal["TaskV1", "TaskV2"] = settings.engine,
+        run_task_timeout_seconds: int = settings.run_task_timeout_seconds,
     ):
         httpx_client = AsyncClient(
             headers={
                 "Content-Type": "application/json",
-                "x-api-key": credential,
+                "x-api-key": api_key,
             },
         )
         self.engine = engine
+        self.run_task_timeout_seconds = run_task_timeout_seconds
         self.client = AsyncSkyvern(base_url=base_url, httpx_client=httpx_client)
 
-    def get_metadata_from_fn_name(
-        self, fn_name: str, spec_functions: List[str | Tuple[str, str]] | None = None
-    ) -> ToolMetadata | None:
-        try:
-            getattr(self, fn_name)
-        except AttributeError:
-            return None
+    async def run_task(self, user_prompt: str, url: Optional[str] = None) -> TaskResponse | Dict[str, Any | None]:
+        """
+        Use Skyvern client to run a task. This function won't return until the task is finished.
 
-        return self.spec_metadata.get(self.engine, {}).get(fn_name)
+        Args:
+            user_prompt[str]: The user's prompt describing the task.
+            url (Optional[str]): The URL of the target website for the task.
+        """
 
-    async def run(self, **kwargs: Dict[str, Any]) -> TaskResponse | Dict[str, Any | None]:
         if self.engine == "TaskV1":
-            return await self.run_task_v1(**kwargs)
+            return await self.run_task_v1(user_prompt=user_prompt, url=url)
         else:
-            return await self.run_task_v2(**kwargs)
+            return await self.run_task_v2(user_prompt=user_prompt, url=url)
+
+    async def dispatch_task(
+        self, user_prompt: str, url: Optional[str] = None
+    ) -> CreateTaskResponse | Dict[str, Any | None]:
+        """
+        Use Skyvern client to dispatch a task. This function will return immediately and the task will be running in the background.
+
+        Args:
+            user_prompt[str]: The user's prompt describing the task.
+            url (Optional[str]): The URL of the target website for the task.
+        """
 
-    async def dispatch(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse | Dict[str, Any | None]:
         if self.engine == "TaskV1":
-            return await self.dispatch_task_v1(**kwargs)
+            return await self.dispatch_task_v1(user_prompt=user_prompt, url=url)
         else:
-            return await self.dispatch_task_v2(**kwargs)
+            return await self.dispatch_task_v2(user_prompt=user_prompt, url=url)
+
+    async def get_task(self, task_id: str) -> TaskResponse | Dict[str, Any | None]:
+        """
+        Use Skyvern client to get a task.
+
+        Args:
+            task_id[str]: The id of the task.
+        """
 
-    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:
             return await self.get_task_v2(task_id)
 
-    async def run_task_v1(self, **kwargs: Dict[str, Any]) -> TaskResponse:
-        task_request = TaskV1Request(**kwargs)
+    async def run_task_v1(self, user_prompt: str, url: Optional[str] = None) -> TaskResponse:
+        task_generation = await self.client.agent.generate_task(
+            prompt=user_prompt,
+        )
+        task_request = TaskRequest.model_validate(task_generation, from_attributes=True)
+        if url is not None:
+            task_request.url = url
+
         return await self.client.agent.run_task(
-            max_steps_override=task_request.max_steps,
-            timeout_seconds=task_request.timeout_seconds,
+            timeout_seconds=self.run_task_timeout_seconds,
             url=task_request.url,
             title=task_request.title,
-            webhook_callback_url=task_request.webhook_callback_url,
-            totp_verification_url=task_request.totp_verification_url,
-            totp_identifier=task_request.totp_identifier,
             navigation_goal=task_request.navigation_goal,
             data_extraction_goal=task_request.data_extraction_goal,
             navigation_payload=task_request.navigation_goal,
             error_code_mapping=task_request.error_code_mapping,
-            proxy_location=task_request.proxy_location,
             extracted_information_schema=task_request.extracted_information_schema,
             complete_criterion=task_request.complete_criterion,
             terminate_criterion=task_request.terminate_criterion,
-            browser_session_id=task_request.browser_session_id,
         )
 
-    async def dispatch_task_v1(self, **kwargs: Dict[str, Any]) -> CreateTaskResponse:
-        task_request = TaskV1Request(**kwargs)
+    async def dispatch_task_v1(self, user_prompt: str, url: Optional[str] = None) -> CreateTaskResponse:
+        task_generation = await self.client.agent.generate_task(
+            prompt=user_prompt,
+        )
+        task_request = TaskRequest.model_validate(task_generation, from_attributes=True)
+        if url is not None:
+            task_request.url = url
+
         return await self.client.agent.create_task(
-            max_steps_override=task_request.max_steps,
             url=task_request.url,
             title=task_request.title,
-            webhook_callback_url=task_request.webhook_callback_url,
-            totp_verification_url=task_request.totp_verification_url,
-            totp_identifier=task_request.totp_identifier,
             navigation_goal=task_request.navigation_goal,
             data_extraction_goal=task_request.data_extraction_goal,
             navigation_payload=task_request.navigation_goal,
             error_code_mapping=task_request.error_code_mapping,
-            proxy_location=task_request.proxy_location,
             extracted_information_schema=task_request.extracted_information_schema,
             complete_criterion=task_request.complete_criterion,
             terminate_criterion=task_request.terminate_criterion,
-            browser_session_id=task_request.browser_session_id,
         )
 
     async def get_task_v1(self, task_id: str) -> TaskResponse:
         return await self.client.agent.get_task(task_id=task_id)
 
-    async def run_task_v2(self, **kwargs: Dict[str, Any]) -> Dict[str, Any | None]:
-        task_request = TaskV2Request(**kwargs)
+    async def run_task_v2(self, user_prompt: str, url: Optional[str] = None) -> Dict[str, Any | None]:
+        task_request = ObserverTaskRequest(url=url, user_prompt=user_prompt)
         return await self.client.agent.run_observer_task_v_2(
-            max_iterations_override=task_request.max_iterations,
-            timeout_seconds=task_request.timeout_seconds,
+            timeout_seconds=self.run_task_timeout_seconds,
             user_prompt=task_request.user_prompt,
             url=task_request.url,
             browser_session_id=task_request.browser_session_id,
-            webhook_callback_url=task_request.webhook_callback_url,
-            totp_verification_url=task_request.totp_verification_url,
-            totp_identifier=task_request.totp_identifier,
-            proxy_location=task_request.proxy_location,
         )
 
-    async def dispatch_task_v2(self, **kwargs: Dict[str, Any]) -> Dict[str, Any | None]:
-        task_request = TaskV2Request(**kwargs)
+    async def dispatch_task_v2(self, user_prompt: str, url: Optional[str] = None) -> Dict[str, Any | None]:
+        task_request = ObserverTaskRequest(url=url, user_prompt=user_prompt)
         return await self.client.agent.observer_task_v_2(
-            max_iterations_override=task_request.max_iterations,
             user_prompt=task_request.user_prompt,
             url=task_request.url,
             browser_session_id=task_request.browser_session_id,
-            webhook_callback_url=task_request.webhook_callback_url,
-            totp_verification_url=task_request.totp_verification_url,
-            totp_identifier=task_request.totp_identifier,
-            proxy_location=task_request.proxy_location,
         )
 
     async def get_task_v2(self, task_id: str) -> Dict[str, Any | None]:

skyvern_llamaindex/settings.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from dotenv import load_dotenv
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    api_key: str = ""
+    base_url: str = "https://api.skyvern.com"
+    engine: Literal["TaskV1", "TaskV2"] = "TaskV2"
+    run_task_timeout_seconds: int = 60 * 60
+
+    class Config:
+        env_prefix = "SKYVERN_"
+
+
+load_dotenv()
+settings = Settings()

skyvern_llamaindex-0.0.4.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.3
+Name: skyvern-llamaindex
+Version: 0.0.4
+Summary: Skyvern integration for LlamaIndex
+Author: lawyzheng
+Author-email: lawy@skyvern.com
+Requires-Python: >=3.11,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: llama-index (>=0.12.19,<0.13.0)
+Requires-Dist: skyvern (>=0.1.56,<0.2.0)
+Description-Content-Type: text/markdown
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
+
+- [Skyvern LlamaIndex](#skyvern-llamaindex)
+  - [Installation](#installation)
+  - [Basic Usage](#basic-usage)
+    - [Run a task(sync) locally in your local environment](#run-a-tasksync-locally-in-your-local-environment)
+    - [Run a task(async) locally in your local environment](#run-a-taskasync-locally-in-your-local-environment)
+    - [Get a task locally in your local environment](#get-a-task-locally-in-your-local-environment)
+    - [Run a task(sync) by calling skyvern APIs](#run-a-tasksync-by-calling-skyvern-apis)
+    - [Run a task(async) by calling skyvern APIs](#run-a-taskasync-by-calling-skyvern-apis)
+    - [Get a task by calling skyvern APIs](#get-a-task-by-calling-skyvern-apis)
+  - [Advanced Usage](#advanced-usage)
+    - [Dispatch a task(async) locally in your local environment and wait until the task is finished](#dispatch-a-taskasync-locally-in-your-local-environment-and-wait-until-the-task-is-finished)
+    - [Dispatch a task(async) by calling skyvern APIs and wait until the task is finished](#dispatch-a-taskasync-by-calling-skyvern-apis-and-wait-until-the-task-is-finished)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# Skyvern LlamaIndex
+
+This is a LlamaIndex integration for Skyvern.
+
+## Installation
+
+```bash
+pip install skyvern-llamaindex
+```
+
+## Basic Usage
+
+### Run a task(sync) locally in your local environment
+> sync task won't return 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.
+
+
+```python
+from dotenv import load_dotenv
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from skyvern_llamaindex.agent import SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.run_task()],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.'")
+print(response)
+```
+
+### Run a task(async) locally in your local environment
+> async task will return immediately and the task will be running in the background.
+
+:warning: :warning: if you want to run the task in the background, you need to keep the agent running until the task is finished, otherwise the task will be killed when the agent finished the chat.
+
+: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.
+
+```python
+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 SkyvernTool
+from llama_index.core.tools import FunctionTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+async def sleep(seconds: int) -> str:
+    await asyncio.sleep(seconds)
+    return f"Slept for {seconds} seconds"
+
+# define a sleep tool to keep the agent running until the task is finished
+sleep_tool = FunctionTool.from_defaults(
+    async_fn=sleep,
+    description="Sleep for a given number of seconds",
+    name="sleep",
+)
+
+skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.dispatch_task(), sleep_tool],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.' Then, sleep for 10 minutes.")
+print(response)
+```
+
+### Get a task locally in your local environment
+
+: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.
+
+```python
+from dotenv import load_dotenv
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from skyvern_llamaindex.agent import SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.get_task()],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Get the task information with Skyvern. The task id is '<task_id>'.")
+print(response)
+```
+
+### Run a task(sync) by calling skyvern APIs
+> sync task won't return until the task is finished.
+
+no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
+
+```python
+from dotenv import load_dotenv
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from skyvern_llamaindex.client import SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+skyvern_tool = SkyvernTool(api_key="<your_organization_api_key>")
+# or you can load the api_key from SKYVERN_API_KEY in .env
+# skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.run_task()],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.'")
+print(response)
+```
+
+### Run a task(async) by calling skyvern APIs
+> async task will return immediately and the task will be running in the background.
+
+no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
+
+the task is actually running in the skyvern cloud service, so you don't need to keep your agent running until the task is finished.
+
+```python
+from dotenv import load_dotenv
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from skyvern_llamaindex.client import SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+skyvern_tool = SkyvernTool(api_key="<your_organization_api_key>")
+# or you can load the api_key from SKYVERN_API_KEY in .env
+# skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.dispatch_task()],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.'")
+print(response)
+```
+
+
+### Get a task by calling skyvern APIs
+
+no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
+
+```python
+from dotenv import load_dotenv
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from skyvern_llamaindex.client import SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+skyvern_tool = SkyvernTool(api_key="<your_organization_api_key>")
+# or you can load the api_key from SKYVERN_API_KEY in .env
+# skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.get_task()],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+)
+
+response = agent.chat("Get the task information with Skyvern. The task id is '<task_id>'.")
+print(response)
+```
+
+## Advanced Usage
+
+To provide some examples of how to integrate Skyvern with other llama-index tools in the agent.
+
+### Dispatch a task(async) locally in your local environment and wait until the task is finished
+> 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.
+
+: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.
+
+```python
+import asyncio
+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 SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+async def sleep(seconds: int) -> str:
+    await asyncio.sleep(seconds)
+    return f"Slept for {seconds} seconds"
+
+sleep_tool = FunctionTool.from_defaults(
+    async_fn=sleep,
+    description="Sleep for a given number of seconds",
+    name="sleep",
+)
+
+skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.dispatch_task(), skyvern_tool.get_task(), sleep_tool],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+    max_function_calls=10,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.' Then, get this task information until it's completed. The task information re-get interval should be 60s.")
+print(response)
+
+```
+
+### Dispatch a task(async) by calling skyvern APIs and wait until the task is finished
+> 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.
+
+no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
+
+```python
+import asyncio
+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 SkyvernTool
+
+# load OpenAI API key from .env
+load_dotenv()
+
+async def sleep(seconds: int) -> str:
+    await asyncio.sleep(seconds)
+    return f"Slept for {seconds} seconds"
+
+sleep_tool = FunctionTool.from_defaults(
+    async_fn=sleep,
+    description="Sleep for a given number of seconds",
+    name="sleep",
+)
+
+skyvern_tool = SkyvernTool(api_key="<your_organization_api_key>")
+# or you can load the api_key from SKYVERN_API_KEY in .env
+# skyvern_tool = SkyvernTool()
+
+agent = OpenAIAgent.from_tools(
+    tools=[skyvern_tool.dispatch_task(), skyvern_tool.get_task(), sleep_tool],
+    llm=OpenAI(model="gpt-4o"),
+    verbose=True,
+    max_function_calls=10,
+)
+
+response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.' Then, get this task information until it's completed. The task information re-get interval should be 60s.")
+print(response)
+
+```

skyvern_llamaindex-0.0.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+skyvern_llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skyvern_llamaindex/agent.py,sha256=BrA9JxqyETTnJcVv_Hj18oFeDesOINpPpXpszh0F-pc,5622
+skyvern_llamaindex/client.py,sha256=JZZXghqLctZ_yV2XwNNOHhHcPYN7Q38jevOAuzUh4JU,6834
+skyvern_llamaindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skyvern_llamaindex/settings.py,sha256=DsW7xaol9azsJ89b9qvJfoB2BWqSR3C5BkiL1aYx8Ws,386
+skyvern_llamaindex-0.0.4.dist-info/METADATA,sha256=xdaJbvcWjUyqbAslNuFAyDixt1JAKTqem67fWMDjYxI,10787
+skyvern_llamaindex-0.0.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+skyvern_llamaindex-0.0.4.dist-info/RECORD,,

{skyvern_llamaindex-0.0.3.dist-info → skyvern_llamaindex-0.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

skyvern_llamaindex/schema.py

@@ -1,18 +0,0 @@
-from pydantic import BaseModel
-
-from skyvern.forge.sdk.schemas.observers import ObserverTaskRequest
-from skyvern.forge.sdk.schemas.tasks import TaskRequest
-
-
-class TaskV1Request(TaskRequest):
-    max_steps: int = 10
-    timeout_seconds: int = 60 * 60
-
-
-class TaskV2Request(ObserverTaskRequest):
-    max_iterations: int = 10
-    timeout_seconds: int = 60 * 60
-
-
-class GetTaskInput(BaseModel):
-    task_id: str

skyvern_llamaindex-0.0.3.dist-info/METADATA

@@ -1,197 +0,0 @@
-Metadata-Version: 2.1
-Name: skyvern-llamaindex
-Version: 0.0.3
-Summary: Skyvern integration for LlamaIndex
-Author: lawyzheng
-Author-email: lawy@skyvern.com
-Requires-Python: >=3.11,<3.12
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: llama-index (>=0.12.19,<0.13.0)
-Requires-Dist: skyvern (>=0.1.56,<0.2.0)
-Description-Content-Type: text/markdown
-
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
-
-- [Skyvern LlamaIndex](#skyvern-llamaindex)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [Run a task(sync) with skyvern agent (calling skyvern agent function directly in the tool)](#run-a-tasksync-with-skyvern-agent-calling-skyvern-agent-function-directly-in-the-tool)
-    - [Dispatch a task(async) with skyvern agent (calling skyvern agent function directly in the tool)](#dispatch-a-taskasync-with-skyvern-agent-calling-skyvern-agent-function-directly-in-the-tool)
-    - [Run a task(sync) with skyvern client (calling skyvern OpenAPI in the tool)](#run-a-tasksync-with-skyvern-client-calling-skyvern-openapi-in-the-tool)
-    - [Dispatch a task(async) with skyvern client (calling skyvern OpenAPI in the tool)](#dispatch-a-taskasync-with-skyvern-client-calling-skyvern-openapi-in-the-tool)
-
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
-
-# Skyvern LlamaIndex
-
-This is a LlamaIndex integration for Skyvern.
-
-## Installation
-
-```bash
-pip install skyvern-llamaindex
-```
-
-## Usage
-
-### Run a task(sync) with skyvern agent (calling skyvern agent function directly in the tool)
-> sync task won't return 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.
-
-
-```python
-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 SkyvernTaskToolSpec
-
-# load OpenAI API key from .env
-load_dotenv()
-
-skyvern_tool = SkyvernTaskToolSpec()
-
-tools = skyvern_tool.to_tool_list(["run"])
-
-agent = OpenAIAgent.from_tools(
-    tools=tools,
-    llm=OpenAI(model="gpt-4o"),
-    verbose=True,
-    max_function_calls=10,
-)
-
-# to run skyvern agent locally, must run `skyvern init` first
-response = agent.chat("Run the task with skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.'")
-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` 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.
-
-```python
-import asyncio
-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 SkyvernTaskToolSpec
-
-async def sleep(seconds: int) -> str:
-    await asyncio.sleep(seconds)
-    return f"Slept for {seconds} seconds"
-
-# load OpenAI API key from .env
-load_dotenv()
-
-skyvern_tool = SkyvernTaskToolSpec()
-
-sleep_tool = FunctionTool.from_defaults(
-    async_fn=sleep,
-    description="Sleep for a given number of seconds",
-    name="sleep",
-)
-
-tools = skyvern_tool.to_tool_list(["dispatch", "get"])
-tools.append(sleep_tool)
-
-agent = OpenAIAgent.from_tools(
-    tools=tools,
-    llm=OpenAI(model="gpt-4o"),
-    verbose=True,
-    max_function_calls=10,
-)
-
-response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.' Then, get this task information until it's completed. The task information re-get interval should be 60s.")
-print(response)
-
-```
-
-### Run a task(sync) with skyvern client (calling skyvern OpenAPI in the tool)
-> sync task won't return until the task is finished.
-
-no need to run `skyvern init` command in your terminal to set up skyvern before using this integration.
-
-```python
-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 SkyvernTaskToolSpec
-
-
-async def sleep(seconds: int) -> str:
-    await asyncio.sleep(seconds)
-    return f"Slept for {seconds} seconds"
-
-# load OpenAI API key from .env
-load_dotenv()
-
-skyvern_client_tool = SkyvernTaskToolSpec(
-    credential="<your_organization_api_key>",
-)
-
-tools = skyvern_client_tool.to_tool_list(["run"])
-
-agent = OpenAIAgent.from_tools(
-    tools=tools,
-    llm=OpenAI(model="gpt-4o"),
-    verbose=True,
-    max_function_calls=10,
-)
-
-response = agent.chat("Run the task with skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.'")
-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` 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.
-
-```python
-import asyncio
-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 SkyvernTaskToolSpec
-
-
-async def sleep(seconds: int) -> str:
-    await asyncio.sleep(seconds)
-    return f"Slept for {seconds} seconds"
-
-# load OpenAI API key from .env
-load_dotenv()
-
-skyvern_client_tool = SkyvernTaskToolSpec(
-    credential="<your_organization_api_key>",
-)
-
-sleep_tool = FunctionTool.from_defaults(
-    async_fn=sleep,
-    description="Sleep for a given number of seconds",
-    name="sleep",
-)
-
-tools = skyvern_client_tool.to_tool_list(["dispatch", "get"])
-tools.append(sleep_tool)
-
-agent = OpenAIAgent.from_tools(
-    tools=tools,
-    llm=OpenAI(model="gpt-4o"),
-    verbose=True,
-    max_function_calls=10,
-)
-
-response = agent.chat("Run a task with Skyvern. The task is about 'Navigate to the Hacker News homepage and get the top 3 posts.' Then, get this task information until it's completed. The task information re-get interval should be 60s.")
-print(response)
-
-```

skyvern_llamaindex-0.0.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-skyvern_llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-skyvern_llamaindex/agent.py,sha256=LAW5IAXkMZL0PR8E2A0bl8KvdGIEnkZCyT3lWZoWVGY,4606
-skyvern_llamaindex/client.py,sha256=o_5fmTFGHpLx-viTegJGiYdDIf11NOP5uXYlc9XXd-w,7682
-skyvern_llamaindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-skyvern_llamaindex/schema.py,sha256=tTvnSC-ms_tW8bnzIn6FXPOCngom7l62B-IyhIwvRxQ,409
-skyvern_llamaindex-0.0.3.dist-info/METADATA,sha256=mewOXnIZlYnvG9c1q-ETn5h5Oqi9gQixeWlHvkdWihc,6704
-skyvern_llamaindex-0.0.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-skyvern_llamaindex-0.0.3.dist-info/RECORD,,