@abide/abide 0.49.0 → 0.50.1

package/src/lib/bundle/disconnected.abide

@@ -149,72 +149,69 @@ async function saveConfig() {
 }
 </script>
 
-<template if={phase === 'splash'}>
+{#if phase === 'splash'}
     <div class="flex min-h-screen items-center justify-center bg-gray-50 dark:bg-gray-950">
-        <template if={logo}>
+        {#if logo}
             <img src={logo} alt="" class="h-16 w-16 rounded-xl object-contain opacity-90" />
-        </template>
+        {/if}
     </div>
-    <template else>
-        <main
-            class="flex min-h-screen items-center justify-center bg-gray-50 p-6 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
-            <div
-                class="w-full max-w-sm rounded-2xl bg-white p-8 shadow-sm ring-1 ring-gray-200 dark:bg-gray-900 dark:ring-gray-800">
-                <template if={logo}>
-                    <img
-                        src={logo}
-                        alt=""
-                        class="mx-auto mb-5 h-16 w-16 rounded-xl object-contain" />
-                </template>
-                <h1 class="mb-6 text-center text-xl font-semibold tracking-tight">{heading}</h1>
-
-                <form class="flex flex-col gap-3" onsubmit={(event) => { event.preventDefault(); void connect() }}>
-                    <input
-                        type="url"
-                        bind:value={url}
-                        placeholder={placeholder}
-                        autocomplete="url"
-                        class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
-                    <button
-                        type="submit"
-                        class="w-full rounded-lg bg-gray-900 px-3 py-2 text-sm font-medium text-white hover:bg-gray-700 dark:bg-gray-100 dark:text-gray-900 dark:hover:bg-gray-300">
-                        Connect
-                    </button>
-                </form>
-
-                <div class="my-5 flex items-center gap-3 text-xs text-gray-400 dark:text-gray-500">
-                    <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
-                    or
-                    <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
-                </div>
+{:else}
+    <main
+        class="flex min-h-screen items-center justify-center bg-gray-50 p-6 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
+        <div
+            class="w-full max-w-sm rounded-2xl bg-white p-8 shadow-sm ring-1 ring-gray-200 dark:bg-gray-900 dark:ring-gray-800">
+            {#if logo}
+                <img
+                    src={logo}
+                    alt=""
+                    class="mx-auto mb-5 h-16 w-16 rounded-xl object-contain" />
+            {/if}
+            <h1 class="mb-6 text-center text-xl font-semibold tracking-tight">{heading}</h1>
 
+            <form class="flex flex-col gap-3" onsubmit={(event) => { event.preventDefault(); void connect() }}>
+                <input
+                    type="url"
+                    bind:value={url}
+                    placeholder={placeholder}
+                    autocomplete="url"
+                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
                 <button
-                    type="button"
-                    onclick={() => void start()}
-                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm font-medium hover:bg-gray-50 dark:border-gray-700 dark:hover:bg-gray-800">
-                    Start server
+                    type="submit"
+                    class="w-full rounded-lg bg-gray-900 px-3 py-2 text-sm font-medium text-white hover:bg-gray-700 dark:bg-gray-100 dark:text-gray-900 dark:hover:bg-gray-300">
+                    Connect
                 </button>
+            </form>
 
-                <template if={error}>
-                    <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">
-                        {error}
-                    </p>
-                </template>
-
-                <p class="mt-8 text-center text-xs text-gray-400 dark:text-gray-500">
-                    made with
-                    <a
-                        href="https://github.com/briancray/abide"
-                        class="underline hover:text-gray-600 dark:hover:text-gray-300"
-                        >abide</a
-                    >
-                </p>
+            <div class="my-5 flex items-center gap-3 text-xs text-gray-400 dark:text-gray-500">
+                <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
+                or
+                <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
             </div>
-        </main>
-    </template>
-</template>
 
-<template if={showConfig}>
+            <button
+                type="button"
+                onclick={() => void start()}
+                class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm font-medium hover:bg-gray-50 dark:border-gray-700 dark:hover:bg-gray-800">
+                Start server
+            </button>
+
+            {#if error}
+                <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">{error}</p>
+            {/if}
+
+            <p class="mt-8 text-center text-xs text-gray-400 dark:text-gray-500">
+                made with
+                <a
+                    href="https://github.com/briancray/abide"
+                    class="underline hover:text-gray-600 dark:hover:text-gray-300"
+                    >abide</a
+                >
+            </p>
+        </div>
+    </main>
+{/if}
+
+{#if showConfig}
     <div
         class="fixed inset-0 z-10 flex items-center justify-center bg-black/40 p-6 text-gray-900 dark:text-gray-100">
         <div
@@ -222,29 +219,28 @@ async function saveConfig() {
             <h2 class="mb-5 text-lg font-semibold tracking-tight">Set up {heading}</h2>
 
             <form class="flex flex-col gap-4" onsubmit={(event) => { event.preventDefault(); void saveConfig() }}>
-                <template each={configFields} as="field" key="field.key">
+                {#for field of configFields by field.key}
                     <label class="flex flex-col gap-1 text-sm">
                         <span class="font-medium">{field.label}</span>
-                        <template if={field.inputType === 'checkbox'}>
+                        {#if field.inputType === 'checkbox'}
                             <input
                                 type="checkbox"
                                 onchange={(event) => { configValues[field.key] = event.currentTarget.checked ? 'true' : 'false' }}
                                 class="mt-1 size-4 self-start rounded border-gray-300 dark:border-gray-700" />
-                            <template else>
-                                <input
-                                    type={field.inputType}
-                                    value={configValues[field.key]}
-                                    oninput={(event) => { configValues[field.key] = event.currentTarget.value }}
-                                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
-                            </template>
-                        </template>
-                        <template if={field.description}>
+                        {:else}
+                            <input
+                                type={field.inputType}
+                                value={configValues[field.key]}
+                                oninput={(event) => { configValues[field.key] = event.currentTarget.value }}
+                                class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
+                        {/if}
+                        {#if field.description}
                             <span class="text-xs text-gray-400 dark:text-gray-500"
                                 >{field.description}</span
                             >
-                        </template>
+                        {/if}
                     </label>
-                </template>
+                {/for}
 
                 <div class="mt-1 flex gap-3">
                     <button
@@ -261,9 +257,9 @@ async function saveConfig() {
                 </div>
             </form>
 
-            <template if={error}>
+            {#if error}
                 <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">{error}</p>
-            </template>
+            {/if}
         </div>
     </div>
-</template>
+{/if}

package/src/lib/bundle/infoPlist.ts

@@ -15,9 +15,15 @@ export function infoPlist({
     version: string
     icon?: string
 }): string {
+    /* Interpolated values ride inside plist `<string>` elements, so any `&`/`<`/`>` in a
+       project name would otherwise emit malformed XML that codesign/Gatekeeper reject. */
+    const escapeXml = (value: string): string =>
+        value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+    const safeName = escapeXml(name)
+    const safeVersion = escapeXml(version)
     const iconEntry = icon
         ? `    <key>CFBundleIconFile</key>
-    <string>${icon}</string>
+    <string>${escapeXml(icon)}</string>
 `
         : ''
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -25,17 +31,17 @@ export function infoPlist({
 <plist version="1.0">
 <dict>
     <key>CFBundleName</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleDisplayName</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleExecutable</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleIdentifier</key>
-    <string>com.abide.${name}</string>
+    <string>com.abide.${safeName}</string>
     <key>CFBundleVersion</key>
-    <string>${version}</string>
+    <string>${safeVersion}</string>
     <key>CFBundleShortVersionString</key>
-    <string>${version}</string>
+    <string>${safeVersion}</string>
 ${iconEntry}    <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>NSHighResolutionCapable</key>

package/src/lib/bundle/spawnEmbeddedServer.ts

@@ -53,10 +53,19 @@ export async function spawnEmbeddedServer({
         env: { ...process.env, PORT: String(port), ABIDE_PARENT_PID: String(process.pid) },
         stdio: ['inherit', 'inherit', 'inherit'],
     })
-    const outcome = await Promise.race([
-        waitForServer(url, timeoutMs ? { timeoutMs } : undefined).then(() => undefined),
-        child.exited,
-    ])
+    let outcome: number | undefined
+    try {
+        outcome = await Promise.race([
+            waitForServer(url, timeoutMs ? { timeoutMs } : undefined).then(() => undefined),
+            child.exited,
+        ])
+    } catch (error) {
+        /* Readiness timed out (waitForServer threw) — reap the child we spawned so it doesn't
+           orphan and hold its fixed PORT, which would then fail the next spawn's bind. The caller
+           only owns the child once we successfully return it. */
+        child.kill()
+        throw error
+    }
     if (outcome !== undefined) {
         throw new Error(`[abide] embedded server exited (code ${outcome}) before binding`)
     }

package/src/lib/bundle/waitForServer.ts

@@ -13,7 +13,12 @@ export async function waitForServer(
     const deadline = Bun.nanoseconds() + timeoutMs * 1e6
     while (Bun.nanoseconds() < deadline) {
         try {
-            await fetch(url)
+            /* Bound each probe by the time left to the deadline: a connection that is accepted but
+               stalls its HTTP response leaves a bare `fetch(url)` pending forever (it never rejects),
+               which would hang the loop past its own timeout. The abort caps a single hung probe at
+               the remaining budget so the deadline is always honored. */
+            const remainingMs = Math.max(0, (deadline - Bun.nanoseconds()) / 1e6)
+            await fetch(url, { signal: AbortSignal.timeout(remainingMs) })
             return
         } catch {
             await Bun.sleep(intervalMs)

package/src/lib/mcp/mcpTools.ts

@@ -1,4 +1,8 @@
 import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
+import {
+    resolveInputJsonSchema,
+    resolveOutputJsonSchema,
+} from '../server/rpc/resolveRpcJsonSchema.ts'
 import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
 import type { RpcRegistryEntry } from '../server/rpc/types/RpcRegistryEntry.ts'
 import { socketOperations } from '../server/sockets/socketOperations.ts'
@@ -37,7 +41,7 @@ RPCs enumerate first, so on a name collision the rpc tool wins.
 function mcpToolRefs(): McpToolRef[] {
     const refs: McpToolRef[] = []
     for (const entry of rpcRegistry.values()) {
-        if (!entry.clients.mcp) {
+        if (!entry.remote.clients.mcp) {
             continue
         }
         refs.push({ kind: 'rpc', name: commandNameForUrl(entry.remote.url), entry })
@@ -63,7 +67,9 @@ from a write.
 */
 function describeTool(ref: McpToolRef): ToolDescriptor {
     if (ref.kind === 'rpc') {
-        const inputSchema = jsonSchemaForSchema(ref.entry.inputSchema)
+        // The declared inputSchema VALIDATOR overrides the build-projected input-type schema
+        // (ADR-0030 input side); with neither the tool advertises the opaque fallback, as before.
+        const inputSchema = resolveInputJsonSchema(ref.entry) ?? jsonSchemaForSchema(undefined)
         const tool: ToolDescriptor = {
             name: ref.name,
             description:
@@ -72,8 +78,11 @@ function describeTool(ref: McpToolRef): ToolDescriptor {
             inputSchema,
             annotations: annotationsForMethod(ref.entry.remote.method),
         }
-        if (ref.entry.outputSchema) {
-            tool.outputSchema = jsonSchemaForSchema(ref.entry.outputSchema)
+        // The declared outputSchema VALIDATOR overrides the build-projected return-type schema
+        // (ADR-0030 D2); with neither the tool advertises no outputSchema, exactly as before.
+        const outputSchema = resolveOutputJsonSchema(ref.entry)
+        if (outputSchema) {
+            tool.outputSchema = outputSchema
         }
         return tool
     }
@@ -149,8 +158,8 @@ function callSocketTool(
         }
     }
     try {
-        // broadcast() validates the payload against the socket schema and throws on failure.
-        entry.socket.broadcast(args)
+        // publish() validates the payload against the socket schema and throws on failure.
+        entry.socket.publish(args)
     } catch (error) {
         return textResult(messageFromError(error), true)
     }

package/src/lib/server/error.ts

@@ -93,15 +93,15 @@ expose the error on `rpc.isError(e, 'name')` (`.kind` and typed `.data`). No
 (a const can't read its own variable name); `schema` types `.data` and is never
 validated at runtime here.
 */
-function typed<Name extends string, Schema extends StandardSchemaV1>(
+function typed<Name extends string, Status extends number, Schema extends StandardSchemaV1>(
     name: Name,
-    status: number,
+    status: Status,
     schema: Schema,
-): (data: StandardSchemaV1.InferInput<Schema>) => TypedError<Name, { status: number; data: Schema }>
-function typed<Name extends string>(
+): (data: StandardSchemaV1.InferInput<Schema>) => TypedError<Name, { status: Status; data: Schema }>
+function typed<Name extends string, Status extends number>(
     name: Name,
-    status: number,
-): () => TypedError<Name, { status: number; data?: undefined }>
+    status: Status,
+): () => TypedError<Name, { status: Status; data?: undefined }>
 function typed(name: string, status: number, _schema?: StandardSchemaV1) {
     return (data?: unknown) => typedErrorResponse(name, status, data)
 }

package/src/lib/server/json.ts

@@ -1,7 +1,13 @@
 import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
+import { encodeWireBody } from '../shared/encodeWireBody.ts'
 import type { TypedResponse } from './rpc/types/TypedResponse.ts'
 import { withResponseDefaults } from './runtime/withResponseDefaults.ts'
 
+/* The Content-Type `Response.json` sets — replicated here because the wire-encode step serializes
+   with a replacer, so the body is built by hand rather than through `Response.json`. Seeds the
+   default header set so an explicit caller `content-type` still wins. */
+const JSON_CONTENT_TYPE = 'application/json;charset=utf-8'
+
 /*
 JSON Response with rpc-friendly defaults — same shape as
 `Response.json(data, init)`, except `Cache-Control: no-store` is set
@@ -36,8 +42,16 @@ export function json<T>(data: T, init?: ResponseInit): TypedResponse<T> {
             withResponseDefaults(init, { 'Cache-Control': NO_STORE }, 204),
         ) as TypedResponse<T>
     }
-    return Response.json(
-        data,
-        withResponseDefaults(init, { 'Cache-Control': NO_STORE }),
+    /* Wire-encode the body (ADR-0029 output path) through the shared honest-JSON encoder: a
+       value-directed replacer rewrites a `Set` → array, a `Map` → `[K,V]` entries, and a `bigint`
+       → digit string, so a structured return crosses as honest JSON rather than a lost `{}` or a
+       500 (plain `Response.json` throws on a bigint). A `Date` already rides as an ISO string via
+       its native `toJSON`. */
+    return new Response(
+        encodeWireBody(data),
+        withResponseDefaults(init, {
+            'Cache-Control': NO_STORE,
+            'Content-Type': JSON_CONTENT_TYPE,
+        }),
     ) as TypedResponse<T>
 }

package/src/lib/server/rpc/defineRpc.ts

@@ -4,10 +4,14 @@ import { createRemoteFunction } from '../../shared/createRemoteFunction.ts'
 import { forwardHeaders } from '../../shared/forwardHeaders.ts'
 import { isReadOnlyMethod } from '../../shared/isReadOnlyMethod.ts'
 import { resolveClientFlags } from '../../shared/resolveClientFlags.ts'
+import type { CachePolicy } from '../../shared/types/CachePolicy.ts'
 import type { ClientFlags } from '../../shared/types/ClientFlags.ts'
+import type { ErrorJsonSchemas } from '../../shared/types/ErrorJsonSchemas.ts'
 import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
+import type { InputCoercion } from '../../shared/types/InputCoercion.ts'
 import type { RemoteFunction } from '../../shared/types/RemoteFunction.ts'
 import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
+import type { StreamPolicy } from '../../shared/types/StreamPolicy.ts'
 import { requestContext } from '../runtime/requestContext.ts'
 import { parseArgs } from './parseArgs.ts'
 import { registerRpc } from './registerRpc.ts'
@@ -50,38 +54,57 @@ export function defineRpc<Args, Return>(
     url: string,
     handler: RemoteHandler<Args, Return>,
     opts?: {
-        inputSchema?: StandardSchemaV1
-        outputSchema?: StandardSchemaV1
-        filesSchema?: StandardSchemaV1
+        /* Namespaced schemas (ADR-0020): `input` types + validates args, `output` is the
+           success-body schema (OpenAPI/MCP), `files` validates multipart File parts. */
+        schemas?: {
+            input?: StandardSchemaV1
+            output?: StandardSchemaV1
+            files?: StandardSchemaV1
+        }
+        /* Surface-exposure flags (browser/mcp/cli) — which surfaces advertise this rpc. */
         clients?: Partial<ClientFlags>
         crossOrigin?: boolean
         /* Per-rpc cap on actual received body bytes (413 past it); omitted = Bun's server-wide maxRequestBodySize. */
         maxBodySize?: number
         /* Per-rpc handler deadline (ms): a 504 once exceeded, on every surface (SSR/MCP/CLI/network). */
         timeout?: number
-        /* Durable delivery: on an unreachable server (transport failure / 502/503/504/52x)
-           the client proxy parks the request for replay instead of just throwing. The
-           parked write drains on `rpc.outbox.retry()` (no auto-drain). Mutating methods
-           only. */
-        outbox?: boolean
-        /* Handler returns jsonl()/sse(): the bare call returns the Subscribable directly (for
+        /* Handler returns jsonl()/sse(): the bare call returns the NamedAsyncIterable directly (for
            isomorphic `for await (… of fn(args))` in server code). Bundler-stamped; the router's
            wire path (.fetch) is unaffected. */
         streaming?: boolean
+        /* Numeric/boolean input fields → parseArgs coerces a string query/form value into the
+           typed value the input schema expects (ADR-0028). Bundler-stamped from the endpoint's
+           `Args` type; absent on the fail-open path (a GET field then stays a string as before). */
+        coerce?: InputCoercion
+        /* The handler's input args projected to JSON Schema (ADR-0030 input side). Bundler-stamped
+           from the endpoint's input-parameter type; feeds the OpenAPI parameters/body / MCP inputSchema
+           / inspector input surface when no `schemas.input` validator is declared (which still
+           overrides it), and makes the endpoint advertisable to MCP/CLI. A SHAPE description only —
+           never runtime-validated, so it can't produce a 422. Absent on the fail-open path — the
+           surface then omits the input schema exactly as before. */
+        inputJsonSchema?: Record<string, unknown>
+        /* The handler's return type projected to JSON Schema (ADR-0030 D2). Bundler-stamped from the
+           endpoint's success-body type; feeds the OpenAPI 200 / MCP outputSchema / inspector surface
+           when no `schemas.output` validator is declared (which still overrides it). Absent on the
+           fail-open path — the surface then omits the response schema exactly as before. */
+        outputJsonSchema?: Record<string, unknown>
+        /* The handler's typed-error branches as a status-keyed JSON-Schema map (ADR-0030). Bundler-
+           stamped from the endpoint's `error.typed(...)` return branches; feeds the OpenAPI
+           `responses[status]` surface so each typed error's status + data payload is documented
+           alongside the 200. Absent on the fail-open path — the surface then omits the error
+           responses exactly as before. */
+        errorJsonSchemas?: ErrorJsonSchemas
+        /* Endpoint cache policy (ADR-0020) — read helpers only; readThrough's bottom layer. */
+        cache?: CachePolicy<Args>
+        /* Endpoint stream policy (ADR-0020) — streaming read helpers only; replay depth `n`. */
+        stream?: StreamPolicy
     },
 ): RemoteFunction<Args, Return> {
-    /* `outbox: true` is a mutation contract — a read RPC has nothing to durably deliver,
-       so reject it at declaration rather than silently ignore. The server handler itself
-       is unaffected; durability is a client-proxy concern. */
-    if (opts?.outbox === true && isReadOnlyMethod(method)) {
-        throw new Error(
-            `[abide] outbox: true is only valid on mutating RPCs (POST/PUT/PATCH/DELETE), not ${method}`,
-        )
-    }
     const timeout = opts?.timeout
-    const inputSchema = opts?.inputSchema
-    const outputSchema = opts?.outputSchema
-    const filesSchema = opts?.filesSchema
+    const inputSchema = opts?.schemas?.input
+    const inputJsonSchema = opts?.inputJsonSchema
+    const outputSchema = opts?.schemas?.output
+    const filesSchema = opts?.schemas?.files
     /*
     An input schema makes the handler safe to advertise to non-browser
     surfaces. CLI flips on for any rpc with one (a human/script invokes it
@@ -89,8 +112,16 @@ export function defineRpc<Args, Return>(
     model shouldn't be able to mutate/delete just because the handler
     carries a schema, so mutating rpcs require an explicit clients.mcp.
     Explicit `clients` always wins.
+
+    A build-projected `inputJsonSchema` (ADR-0030 input side — the handler's
+    input parameter type projected to JSON Schema, present only when the type
+    resolved cleanly) counts as a machine-advertisable contract too, so a
+    plainly-typed handler auto-exposes without a hand-written `schemas.input`.
+    This is SHAPE-only: the projection describes the input, it is NEVER run as
+    runtime validation (no 422) — declaring `schemas.input` is still what adds
+    the runtime narrowing.
     */
-    const hasSchema = inputSchema !== undefined
+    const hasSchema = inputSchema !== undefined || inputJsonSchema !== undefined
     const clients = resolveClientFlags(opts?.clients, {
         mcp: hasSchema && isReadOnlyMethod(method),
         cli: hasSchema,
@@ -189,10 +220,12 @@ export function defineRpc<Args, Return>(
         clients,
         streaming: opts?.streaming ?? false,
         crossOrigin: opts?.crossOrigin,
+        cache: opts?.cache,
+        stream: opts?.stream,
         buildRequest,
         invoke,
         parseArgsForFetch: async (request) => {
-            const args = await parseArgs(method, request, opts?.maxBodySize)
+            const args = await parseArgs(method, request, opts?.maxBodySize, opts?.coerce)
             /*
             Compose this rpc's deadline into request().signal so a handler's
             fetch(ext, { signal: request().signal }) is cancelled when the
@@ -225,12 +258,13 @@ export function defineRpc<Args, Return>(
     registerRpc({
         remote: remote as RemoteFunction<unknown, unknown>,
         inputSchema,
+        inputJsonSchema,
         outputSchema,
+        outputJsonSchema: opts?.outputJsonSchema,
+        errorJsonSchemas: opts?.errorJsonSchemas,
         filesSchema,
-        clients,
         timeout,
         maxBodySize: opts?.maxBodySize,
-        crossOrigin: opts?.crossOrigin,
     })
     return remote
 }