A desktop coding agent with free access to frontier models.
TypeScript
import { Agent, fetch as undiciFetch } from "undici"
export type FetchLike = (url: string, init: RequestInit) => Promise<Response>
const connectPhaseErrorCodes = new Set([
"UND_ERR_CONNECT_TIMEOUT",
"ECONNREFUSED",
"ENOTFOUND",
"EAI_AGAIN",
"ETIMEDOUT",
"ECONNRESET",
])
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null
}
export function isConnectPhaseError(error: unknown): boolean {
let current = error
const visited = new Set<object>()
while (isRecord(current) && !visited.has(current)) {
visited.add(current)
if ((typeof current.code === "string" && connectPhaseErrorCodes.has(current.code)) || current.name === "ConnectTimeoutError") {
return true
}
current = current.cause
}
return false
}
export async function fetchWithConnectRetry(input: {
fetchImpl: FetchLike
url: string
init: RequestInit
retries?: number
}): Promise<Response> {
let retriesRemaining = input.retries ?? 1
while (true) {
try {
return await input.fetchImpl(input.url, input.init)
} catch (error) {
if (!isConnectPhaseError(error) || retriesRemaining <= 0) {
throw error
}
retriesRemaining -= 1
}
}
}
export function createInstanceFetch(options: { connectTimeoutMs: number }): FetchLike {
const agent = new Agent({
connect: {
timeout: options.connectTimeoutMs,
autoSelectFamily: true,
autoSelectFamilyAttemptTimeout: 300,
},
keepAliveTimeout: 60_000,
keepAliveMaxTimeout: 300_000,
headersTimeout: 30_000,
bodyTimeout: 0,
})
return async (url, init) => {
const request = new Request(url, init)
const headers: Record<string, string> = {}
request.headers.forEach((value, name) => {
headers[name] = value
})
const response = await undiciFetch(url, {
method: request.method,
headers,
body: request.body ? await request.arrayBuffer() : undefined,
redirect: request.redirect,
dispatcher: agent,
})
const responseHeaders = new Headers()
response.headers.forEach((value, name) => {
responseHeaders.append(name, value)
})
let body: ReadableStream<Uint8Array> | null = null
if (response.body) {
const reader = response.body.getReader()
body = new ReadableStream<Uint8Array>({
async pull(controller) {
const chunk = await reader.read()
if (chunk.done) {
controller.close()
return
}
controller.enqueue(chunk.value)
},
cancel(reason: unknown) {
return reader.cancel(reason)
},
})
}
return new Response(body, {
status: response.status,
statusText: response.statusText,
headers: responseHeaders,
})
}
}