Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

Create read docs tool

Vasek Mlejnskyf22c0035fe31
diff --git a/api-service/cf-worker-template/index.js b/api-service/cf-worker-template/index.js
index 72ecc3992..2d881929c 100644
--- a/api-service/cf-worker-template/index.js
+++ b/api-service/cf-worker-template/index.js
@@ -3,10 +3,10 @@ import { Router } from 'itty-router'
const router = Router()
async function handlepostRequest(request) {
- const data = await request.json()
- const { email } = data
- const regex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
- if (!regex.test(String(email).toLowerCase())) {
+ const body = await request.json()
+ const { email } = body
+ const emailRegex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+ if (!emailRegex.test(email)) {
return new Response(JSON.stringify({ error: 'Invalid email' }), { status: 400 })
}
return new Response(JSON.stringify({ message: 'Ok' }))
diff --git a/api-service/codegen/base.py b/api-service/codegen/base.py
index 0c1ea57ec..16ae29ab2 100644
--- a/api-service/codegen/base.py
+++ b/api-service/codegen/base.py
@@ -3,6 +3,7 @@ import uuid
from langchain.llms.openai import OpenAIChat, OpenAI
from codegen.tools.javascript.tool import JavascriptEvalTool
+from codegen.tools.documentation.tool import ReadDocumentation
from codegen.js_agent.base import create_js_agent
from codegen.prompt import PREFIX, SUFFIX
@@ -16,7 +17,8 @@ def generate_req_handler(project_id: str, blocks: List[str], method: str) -> str
llm=OpenAI(temperature=0, max_tokens=1000),
# llm=OpenAI(temperature=0, model_name='code-davinci-002', max_tokens=1000),
# llm=OpenAIChat(temperature=0, max_tokens=1000),
- tool=JavascriptEvalTool(),
+ # tools=[JavascriptEvalTool(), ReadDocumentation()],
+ tools=[JavascriptEvalTool()],
verbose=True,
)
diff --git a/api-service/codegen/js_agent/base.py b/api-service/codegen/js_agent/base.py
index 2e7f4f5a9..3ac250dc6 100644
--- a/api-service/codegen/js_agent/base.py
+++ b/api-service/codegen/js_agent/base.py
@@ -1,7 +1,6 @@
-from typing import Any, Optional
+from typing import Any, Optional, List
from langchain.agents.agent import AgentExecutor
-from langchain.agents import initialize_agent
from langchain.callbacks.base import BaseCallbackManager
from langchain.llms.base import BaseLLM
from langchain.agents.mrkl.base import ZeroShotAgent
@@ -9,8 +8,11 @@ from langchain.chains.llm import LLMChain
from langchain.callbacks.shared import SharedCallbackManager
from codegen.js_agent.prompt import PREFIX
-from codegen.tools.javascript.tool import JavascriptEvalTool
+from langchain.tools.base import BaseTool
+
+# from codegen.tools.javascript.tool import JavascriptEvalTool
from codegen.js_agent.callbacks.log import LoggerCallbackHandler
+
# from js_agent.prompt import PREFIX
# from tools.javascript.tool import JavascriptEvalTool
@@ -19,33 +21,24 @@ def create_js_agent(
run_id: str,
project_id: str,
llm: BaseLLM,
- tool: JavascriptEvalTool,
+ tools: List[BaseTool],
callback_manager: Optional[BaseCallbackManager] = None,
verbose: bool = False,
prefix: str = PREFIX,
**kwargs: Any,
) -> AgentExecutor:
"""Construct a javascript agent that generates code from an LLM and tool."""
- tools = [tool]
- prompt = ZeroShotAgent.create_prompt(
- tools=tools,
- prefix=prefix
- )
+ prompt = ZeroShotAgent.create_prompt(tools=tools, prefix=prefix)
llm_chain = LLMChain(
llm=llm,
prompt=prompt,
callback_manager=callback_manager,
)
tool_names = [tool.name for tool in tools]
- agent = ZeroShotAgent(llm_chain=llm_chain,
- allowed_tools=tool_names, **kwargs)
+ agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
cb_manager = SharedCallbackManager()
- cb_manager.set_handler(LoggerCallbackHandler(
- run_id=run_id, project_id=project_id))
+ cb_manager.set_handler(LoggerCallbackHandler(run_id=run_id, project_id=project_id))
return AgentExecutor.from_agent_and_tools(
- agent=agent,
- tools=tools,
- verbose=verbose,
- callback_manager=cb_manager
+ agent=agent, tools=tools, verbose=verbose, callback_manager=cb_manager
)
diff --git a/api-service/codegen/tools/documentation/__init__.py b/api-service/codegen/tools/documentation/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/api-service/codegen/tools/documentation/readme.md b/api-service/codegen/tools/documentation/readme.md
new file mode 100644
index 000000000..86bb9a1b7
--- /dev/null
+++ b/api-service/codegen/tools/documentation/readme.md
@@ -0,0 +1,117 @@
+# [![Itty Router](https://user-images.githubusercontent.com/865416/146679767-16be95b4-5dd7-4bcf-aed7-b8aa8c828f48.png)](https://itty-router.dev)
+
+## Usage
+### 1. Create a Router
+```js
+import { Router } from 'itty-router'
+
+const router = Router() // no "new", as this is not a real class
+```
+
+### 2. Register Route(s)
+##### `router.{method}(route: string, handler1: function, handler2: function, ...)`
+```js
+// register a route on the "GET" method
+router.get('/todos/:user/:item?', (req) => {
+ const { params, query } = req
+
+ console.log({ params, query })
+})
+```
+
+### 3. Handle Incoming Request(s)
+##### `async router.handle(request.proxy: Proxy || request: Request, ...anything else) => Promise<any>`
+Requests (doesn't have to be a real Request class) should have both a **method** and full **url**.
+The `handle` method will then return a Promise, resolving with the first matching route handler that returns something (or nothing at all if no match).
+
+```js
+router.handle({
+ method: 'GET', // required
+ url: 'https://example.com/todos/jane/13', // required
+})
+```
+
+#### A few notes about this:
+- **Error Handling:** By default, there is no error handling built in to itty. However, the handle function is async, allowing you to add a `.catch(error)` like this:
+
+ ```js
+ import { Router } from 'itty-router'
+
+ // a generic error handler
+ const errorHandler = error =>
+ new Response(error.message || 'Server Error', { status: error.status || 500 })
+
+ // add some routes (will both safely trigger errorHandler)
+ router
+ .get('/accidental', request => request.that.will.throw)
+ .get('/intentional', () => {
+ throw new Error('Bad Request')
+ })
+
+ // attach the router "handle" to the event handler
+ addEventListener('fetch', event =>
+ event.respondWith(
+ router
+ .handle(event.request)
+ .catch(errorHandler)
+ )
+ )
+ ```
+- **Extra Variables:** The router handle expects only the request itself, but passes along any additional params to the handlers/middleware. For example, to access the `event` itself within a handler (e.g. for `event.waitUntil()`), you could simply do this:
+
+ ```js
+ const router = Router()
+
+ router.get('/long-task', (request, event) => {
+ event.waitUntil(longAsyncTaskPromise)
+
+ return new Response('Task is still running in the background!')
+ })
+
+ addEventListener('fetch', event =>
+ event.respondWith(router.handle(event.request, event))
+ )
+ ```
+- **Proxies:** To allow for some pretty incredible middleware hijacks, we pass `request.proxy` (if it exists) or `request` (if not) to the handler. This allows middleware to set `request.proxy = new Proxy(request.proxy || request, {})` and effectively take control of reads/writes to the request object itself. As an example, the `withParams` middleware in `itty-router-extras` uses this to control future reads from the request. It intercepts "get" on the Proxy, first checking the requested attribute within the `request.params` then falling back to the `request` itself.
+
+## Examples
+
+### File format support
+```js
+// GET item with optional format/extension
+router.get('/todos/:id.:format?', request => {
+ const { id, format = 'csv' } = request.params
+
+ return new Response(`Getting todo #${id} in ${format} format.`)
+})
+```
+
+### Cloudflare ES6 Module Syntax (required for Durable Objects) <a id="cf-es6-module-syntax"></a>
+See https://developers.cloudflare.com/workers/runtime-apis/fetch-event#syntax-module-worker
+```js
+import { Router } from 'itty-router'
+
+const router = Router()
+
+router.get('/', (request, env, context) => {
+ // now have access to the env (where CF bindings like durables, KV, etc now are)
+})
+
+export default {
+ fetch: router.handle // yep, it's this easy.
+}
+
+// alternative advanced/manual approach for downstream control
+export default {
+ fetch: (request, env, context) => router
+ .handle(request, env, context)
+ .then(response => {
+ // can modify response here before final return, e.g. CORS headers
+
+ return response
+ })
+ .catch(err => {
+ // and do something with the errors here, like logging, error status, etc
+ })
+}
+```
diff --git a/api-service/codegen/tools/documentation/tool.py b/api-service/codegen/tools/documentation/tool.py
new file mode 100644
index 000000000..40e9a05c5
--- /dev/null
+++ b/api-service/codegen/tools/documentation/tool.py
@@ -0,0 +1,20 @@
+from langchain.tools.base import BaseTool
+
+
+class ReadDocumentation(BaseTool):
+ name = "Read Documentation"
+ description = (
+ "Read quickstart documentation of a third party library or package."
+ "The library or package must be hosted on GitHub and publicly accessible."
+ "Input must be a link to a public GitHub repository where the library or the package is hosted."
+ )
+
+ def _run(self, query: str) -> str:
+ f = open(
+ "/Users/vasekmlejnsky/Developer/ai-api/api-service/codegen/tools/documentation/readme.md",
+ "r",
+ )
+ return f.read()
+
+ async def _arun(self, query: str) -> str:
+ return NotImplementedError("ReadDocumentation does not support async")
diff --git a/api-service/codegen/tools/javascript/tool.py b/api-service/codegen/tools/javascript/tool.py
index b23e9905c..ba9b01400 100644
--- a/api-service/codegen/tools/javascript/tool.py
+++ b/api-service/codegen/tools/javascript/tool.py
@@ -1,8 +1,6 @@
"""A tool for running javascript code in eval() on remote endpoint"""
from langchain.tools.base import BaseTool
-
-# from tools.javascript.eval import eval as js_eval
from codegen.tools.javascript.eval import eval as js_eval
@@ -14,7 +12,7 @@ class JavascriptEvalTool(BaseTool):
)
def _run(self, query: str) -> str:
- query = query.strip().strip('`')
+ query = query.strip().strip("`")
return js_eval(query)
async def _arun(self, query: str) -> str:
diff --git a/components/Text.tsx b/components/Text.tsx
index 1c7354a49..7d0c457e3 100644
--- a/components/Text.tsx
+++ b/components/Text.tsx
@@ -22,7 +22,14 @@ const Sizes = {
[Size.S3]: 'text-xs space-x-1',
}
-function Text({ className, text, size = Size.S2, icon, onClick, suppressHydrationWarning }: Props) {
+function Text({
+ className,
+ text,
+ size = Size.S2,
+ icon,
+ onClick,
+ suppressHydrationWarning,
+}: Props) {
const classes = clsx(
'flex',
'flex-row',