openAgent

1export * as ToolSandbox from "./sandbox"
2 
3import { Context, Effect, Layer, Schema } from "effect"
4import { ToolFailure } from "@opencode-ai/llm"
5import { ToolDefinitionRecord } from "./metadata"
6import { CredentialBroker } from "../credential/broker"
7import { SecretRedactor } from "../credential/redactor"
8import { makeGlobalNode } from "../effect/app-node"
9 
10export class SandboxExecutionError extends Schema.TaggedErrorClass<SandboxExecutionError>()(
11  "ToolSandbox.ExecutionError",
12  {
13    tool: Schema.String,
14    message: Schema.String,
15  },
16) {}
17 
18export interface Interface {
19  readonly execute: (
20    tool: ToolDefinitionRecord,
21    input: unknown,
22  ) => Effect.Effect<unknown, ToolFailure>
23}
24 
25export class Service extends Context.Service<Service, Interface>()("@openagent/ToolSandbox") {}
26 
27const layer = Layer.effect(
28  Service,
29  Effect.gen(function* () {
30    const credentials = yield* CredentialBroker.Service
31 
32    const executeHttp = async (
33      tool: ToolDefinitionRecord,
34      input: Record<string, unknown>,
35      creds: Record<string, string>,
36    ): Promise<unknown> => {
37      let endpoint = tool.endpoint ?? ""
38      // Interpolate params into endpoint e.g. https://api.linear.app/graphql or https://api.github.com/repos/{owner}/{repo}
39      for (const [k, v] of Object.entries(input)) {
40        if (endpoint.includes(`{${k}}`)) {
41          endpoint = endpoint.replaceAll(`{${k}}`, encodeURIComponent(String(v)))
42        }
43      }
44 
45      // Build headers
46      const headers: Record<string, string> = {
47        "Content-Type": "application/json",
48        Accept: "application/json",
49        "User-Agent": "OpenAgent-UniversalRuntime/1.0",
50        ...(tool.headers ?? {}),
51      }
52 
53      // Inject credentials into headers if specified or template
54      for (const [k, v] of Object.entries(headers)) {
55        let val = v
56        for (const [credKey, credVal] of Object.entries(creds)) {
57          val = val.replaceAll(`$${credKey}`, credVal).replaceAll(`{${credKey}}`, credVal)
58        }
59        headers[k] = val
60      }
61 
62      const method = tool.method ?? "POST"
63      let body: string | undefined = undefined
64 
65      if (method !== "GET") {
66        if (tool.bodyTemplate) {
67          let b = tool.bodyTemplate
68          for (const [k, v] of Object.entries(input)) {
69            b = b.replaceAll(`{${k}}`, JSON.stringify(v)).replaceAll(`$${k}`, String(v))
70          }
71          body = b
72        } else {
73          body = JSON.stringify(input)
74        }
75      }
76 
77      const controller = new AbortController()
78      const timeout = setTimeout(() => controller.abort(), 30000)
79 
80      try {
81        const response = await fetch(endpoint, {
82          method,
83          headers,
84          body,
85          signal: controller.signal,
86        })
87        clearTimeout(timeout)
88 
89        const text = await response.text()
90        let parsed: unknown
91        try {
92          parsed = JSON.parse(text)
93        } catch {
94          parsed = { status: response.status, body: text }
95        }
96 
97        if (!response.ok) {
98          throw new Error(`HTTP ${response.status} ${response.statusText}: ${typeof parsed === "object" ? JSON.stringify(parsed) : String(parsed)}`)
99        }
100 
101        return SecretRedactor.redactObject(parsed)
102      } catch (e: any) {
103        clearTimeout(timeout)
104        throw new Error(SecretRedactor.redact(e.message ?? "HTTP request failed"))
105      }
106    }
107 
108    const executeCode = async (
109      tool: ToolDefinitionRecord,
110      input: unknown,
111      creds: Record<string, string>,
112    ): Promise<unknown> => {
113      const code = tool.code ?? ""
114      if (!code) {
115        throw new Error(`No code implementation provided for tool "${tool.name}".`)
116      }
117 
118      // Provide controlled sandbox scope with ONLY declared credentials
119      const sandboxEnv = Object.freeze({ ...creds })
120      
121      const runner = new Function(
122        "input",
123        "env",
124        "fetch",
125        `"use strict";
126        return (async () => {
127          ${code}
128        })();`,
129      )
130 
131      const timeoutPromise = new Promise((_, reject) =>
132        setTimeout(() => reject(new Error(`Tool "${tool.name}" execution timed out after 30s.`)), 30000),
133      )
134 
135      const executionPromise = runner(input, sandboxEnv, fetch)
136      const rawResult = await Promise.race([executionPromise, timeoutPromise])
137      return SecretRedactor.redactObject(rawResult)
138    }
139 
140    return Service.of({
141      execute: Effect.fn("ToolSandbox.execute")(function* (tool: ToolDefinitionRecord, input: unknown) {
142        // Resolve only declared credentials
143        const creds = yield* credentials
144          .resolveManyForTool(tool.name, tool.credentials)
145          .pipe(
146            Effect.mapError(
147              (err) => new ToolFailure({ message: `Credential resolution error: ${err.message}` }),
148            ),
149          )
150 
151        return yield* Effect.tryPromise({
152          try: async () => {
153            if (tool.executionMethod === "http" || tool.endpoint) {
154              return await executeHttp(tool, (input ?? {}) as Record<string, unknown>, creds)
155            }
156            return await executeCode(tool, input, creds)
157          },
158          catch: (err: any) =>
159            new ToolFailure({
160              message: SecretRedactor.redact(`Execution failure in "${tool.name}": ${err?.message ?? String(err)}`),
161            }),
162        })
163      }),
164    })
165  }),
166)
167 
168export const defaultLayer = layer
169export const node = makeGlobalNode({ service: Service, layer, deps: [CredentialBroker.node] })
170