@ericsanchezok/synergy-sdk 0.0.2 → 1.0.0

package/dist/client.d.ts

@@ -1,11 +1,11 @@
 export * from "./gen/types.gen.js";
 import { type Config } from "./gen/client/types.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
+import { SynergyClient } from "./gen/sdk.gen.js";
 export { type Config as SynergyClientConfig };
 export { type Config as OpencodeClientConfig };
-export { OpencodeClient as SynergyClient, OpencodeClient };
+export { SynergyClient, SynergyClient as OpencodeClient };
 export declare function createSynergyClient(config?: Config & {
     directory?: string;
-}): OpencodeClient;
+}): SynergyClient;
 /** @deprecated Use createSynergyClient instead */
 export declare const createOpencodeClient: typeof createSynergyClient;

package/dist/client.js

@@ -1,7 +1,7 @@
 export * from "./gen/types.gen.js";
 import { createClient } from "./gen/client/client.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export { OpencodeClient as SynergyClient, OpencodeClient };
+import { SynergyClient } from "./gen/sdk.gen.js";
+export { SynergyClient, SynergyClient as OpencodeClient };
 export function createSynergyClient(config) {
     if (!config?.fetch) {
         const customFetch = (req) => {
@@ -15,13 +15,15 @@ export function createSynergyClient(config) {
         };
     }
     if (config?.directory) {
+        const isNonASCII = /[^\x00-\x7F]/.test(config.directory);
+        const encodedDirectory = isNonASCII ? encodeURIComponent(config.directory) : config.directory;
         config.headers = {
             ...config.headers,
-            "x-synergy-directory": config.directory,
+            "x-synergy-directory": encodedDirectory,
         };
     }
     const client = createClient(config);
-    return new OpencodeClient({ client });
+    return new SynergyClient({ client });
 }
 /** @deprecated Use createSynergyClient instead */
 export const createOpencodeClient = createSynergyClient;

package/dist/gen/client/client.gen.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 import { createSseClient } from "../core/serverSentEvents.gen.js";
+import { getValidRequestBody } from "../core/utils.gen.js";
 import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from "./utils.gen.js";
 export const createClient = (config = {}) => {
     let _config = mergeConfigs(createConfig(), config);
@@ -26,11 +27,11 @@ export const createClient = (config = {}) => {
         if (opts.requestValidator) {
             await opts.requestValidator(opts);
         }
-        if (opts.body && opts.bodySerializer) {
+        if (opts.body !== undefined && opts.bodySerializer) {
             opts.serializedBody = opts.bodySerializer(opts.body);
         }
         // remove Content-Type header if body is empty to avoid sending invalid requests
-        if (opts.serializedBody === undefined || opts.serializedBody === "") {
+        if (opts.body === undefined || opts.serializedBody === "") {
             opts.headers.delete("Content-Type");
         }
         const url = buildUrl(opts);
@@ -42,10 +43,10 @@ export const createClient = (config = {}) => {
         const requestInit = {
             redirect: "follow",
             ...opts,
-            body: opts.serializedBody,
+            body: getValidRequestBody(opts),
         };
         let request = new Request(url, requestInit);
-        for (const fn of interceptors.request._fns) {
+        for (const fn of interceptors.request.fns) {
             if (fn) {
                 request = await fn(request, opts);
             }
@@ -53,8 +54,32 @@ export const createClient = (config = {}) => {
         // fetch must be assigned here, otherwise it would throw the error:
         // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
         const _fetch = opts.fetch;
-        let response = await _fetch(request);
-        for (const fn of interceptors.response._fns) {
+        let response;
+        try {
+            response = await _fetch(request);
+        }
+        catch (error) {
+            // Handle fetch exceptions (AbortError, network errors, etc.)
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = (await fn(error, undefined, request, opts));
+                }
+            }
+            finalError = finalError || {};
+            if (opts.throwOnError) {
+                throw finalError;
+            }
+            // Return error response
+            return opts.responseStyle === "data"
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response: undefined,
+                };
+        }
+        for (const fn of interceptors.response.fns) {
             if (fn) {
                 response = await fn(response, request, opts);
             }
@@ -64,15 +89,33 @@ export const createClient = (config = {}) => {
             response,
         };
         if (response.ok) {
+            const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
             if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+                let emptyData;
+                switch (parseAs) {
+                    case "arrayBuffer":
+                    case "blob":
+                    case "text":
+                        emptyData = await response[parseAs]();
+                        break;
+                    case "formData":
+                        emptyData = new FormData();
+                        break;
+                    case "stream":
+                        emptyData = response.body;
+                        break;
+                    case "json":
+                    default:
+                        emptyData = {};
+                        break;
+                }
                 return opts.responseStyle === "data"
-                    ? {}
+                    ? emptyData
                     : {
-                        data: {},
+                        data: emptyData,
                         ...result,
                     };
             }
-            const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
             let data;
             switch (parseAs) {
                 case "arrayBuffer":
@@ -115,7 +158,7 @@ export const createClient = (config = {}) => {
         }
         const error = jsonError ?? textError;
         let finalError = error;
-        for (const fn of interceptors.error._fns) {
+        for (const fn of interceptors.error.fns) {
             if (fn) {
                 finalError = (await fn(error, response, request, opts));
             }
@@ -132,34 +175,51 @@ export const createClient = (config = {}) => {
                 ...result,
             };
     };
-    const makeMethod = (method) => {
-        const fn = (options) => request({ ...options, method });
-        fn.sse = async (options) => {
-            const { opts, url } = await beforeRequest(options);
-            return createSseClient({
-                ...opts,
-                body: opts.body,
-                headers: opts.headers,
-                method,
-                url,
-            });
-        };
-        return fn;
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            url,
+        });
     };
     return {
         buildUrl,
-        connect: makeMethod("CONNECT"),
-        delete: makeMethod("DELETE"),
-        get: makeMethod("GET"),
+        connect: makeMethodFn("CONNECT"),
+        delete: makeMethodFn("DELETE"),
+        get: makeMethodFn("GET"),
         getConfig,
-        head: makeMethod("HEAD"),
+        head: makeMethodFn("HEAD"),
         interceptors,
-        options: makeMethod("OPTIONS"),
-        patch: makeMethod("PATCH"),
-        post: makeMethod("POST"),
-        put: makeMethod("PUT"),
+        options: makeMethodFn("OPTIONS"),
+        patch: makeMethodFn("PATCH"),
+        post: makeMethodFn("POST"),
+        put: makeMethodFn("PUT"),
         request,
         setConfig,
-        trace: makeMethod("TRACE"),
+        sse: {
+            connect: makeSseFn("CONNECT"),
+            delete: makeSseFn("DELETE"),
+            get: makeSseFn("GET"),
+            head: makeSseFn("HEAD"),
+            options: makeSseFn("OPTIONS"),
+            patch: makeSseFn("PATCH"),
+            post: makeSseFn("POST"),
+            put: makeSseFn("PUT"),
+            trace: makeSseFn("TRACE"),
+        },
+        trace: makeMethodFn("TRACE"),
     };
 };

package/dist/gen/client/index.d.ts

@@ -2,6 +2,7 @@ export type { Auth } from "../core/auth.gen.js";
 export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js";
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
 export { buildClientParams } from "../core/params.gen.js";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js";
 export { createClient } from "./client.gen.js";
-export type { Client, ClientOptions, Config, CreateClientConfig, Options, OptionsLegacyParser, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from "./types.gen.js";
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from "./types.gen.js";
 export { createConfig, mergeHeaders } from "./utils.gen.js";

package/dist/gen/client/index.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
 export { buildClientParams } from "../core/params.gen.js";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js";
 export { createClient } from "./client.gen.js";
 export { createConfig, mergeHeaders } from "./utils.gen.js";

package/dist/gen/client/types.gen.d.ts

@@ -14,7 +14,7 @@ export interface Config<T extends ClientOptions = ClientOptions> extends Omit<Re
      *
      * @default globalThis.fetch
      */
-    fetch?: (request: Request) => ReturnType<typeof fetch>;
+    fetch?: typeof fetch;
     /**
      * Please don't use the Fetch client for Next.js applications. The `next`
      * options won't have any effect.
@@ -84,19 +84,16 @@ export interface ClientOptions {
     responseStyle?: ResponseStyle;
     throwOnError?: boolean;
 }
-type MethodFnBase = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type MethodFnServerSentEvents = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-type MethodFn = MethodFnBase & {
-    sse: MethodFnServerSentEvents;
-};
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
     url: string;
-}>(options: Pick<TData, "url"> & Options<TData>) => string;
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
+}>(options: TData & Options<TData>) => string;
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
     interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
 };
 /**
@@ -116,12 +113,5 @@ export interface TDataShape {
     url: string;
 }
 type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
-export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & Omit<TData, "url">;
-export type OptionsLegacyParser<TData = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = TData extends {
-    body?: any;
-} ? TData extends {
-    headers?: any;
-} ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "headers" | "url"> & TData : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "url"> & TData & Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers"> : TData extends {
-    headers?: any;
-} ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers" | "url"> & TData & Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body"> : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "url"> & TData;
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & ([TData] extends [never] ? unknown : Omit<TData, "url">);
 export {};

package/dist/gen/client/utils.gen.d.ts

@@ -1,6 +1,6 @@
 import type { QuerySerializerOptions } from "../core/bodySerializer.gen.js";
 import type { Client, ClientOptions, Config, RequestOptions } from "./types.gen.js";
-export declare const createQuerySerializer: <T = unknown>({ allowReserved, array, object }?: QuerySerializerOptions) => (queryParams: T) => string;
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
 /**
  * Infers parseAs value from provided Content-Type header.
  */
@@ -15,24 +15,19 @@ type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, reques
 type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {
-    _fns: (Interceptor | null)[];
-    constructor();
+    fns: Array<Interceptor | null>;
     clear(): void;
-    getInterceptorIndex(id: number | Interceptor): number;
-    exists(id: number | Interceptor): boolean;
     eject(id: number | Interceptor): void;
-    update(id: number | Interceptor, fn: Interceptor): number | false | Interceptor;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
     use(fn: Interceptor): number;
 }
 export interface Middleware<Req, Res, Err, Options> {
-    error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, "eject" | "use">;
-    request: Pick<Interceptors<ReqInterceptor<Req, Options>>, "eject" | "use">;
-    response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, "eject" | "use">;
-}
-export declare const createInterceptors: <Req, Res, Err, Options>() => {
     error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
     request: Interceptors<ReqInterceptor<Req, Options>>;
     response: Interceptors<ResInterceptor<Res, Req, Options>>;
-};
+}
+export declare const createInterceptors: <Req, Res, Err, Options>() => Middleware<Req, Res, Err, Options>;
 export declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
 export {};

package/dist/gen/client/utils.gen.js

@@ -3,7 +3,7 @@ import { getAuthToken } from "../core/auth.gen.js";
 import { jsonBodySerializer } from "../core/bodySerializer.gen.js";
 import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam } from "../core/pathSerializer.gen.js";
 import { getUrl } from "../core/utils.gen.js";
-export const createQuerySerializer = ({ allowReserved, array, object } = {}) => {
+export const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
     const querySerializer = (queryParams) => {
         const search = [];
         if (queryParams && typeof queryParams === "object") {
@@ -12,33 +12,34 @@ export const createQuerySerializer = ({ allowReserved, array, object } = {}) =>
                 if (value === undefined || value === null) {
                     continue;
                 }
+                const options = parameters[name] || args;
                 if (Array.isArray(value)) {
                     const serializedArray = serializeArrayParam({
-                        allowReserved,
+                        allowReserved: options.allowReserved,
                         explode: true,
                         name,
                         style: "form",
                         value,
-                        ...array,
+                        ...options.array,
                     });
                     if (serializedArray)
                         search.push(serializedArray);
                 }
                 else if (typeof value === "object") {
                     const serializedObject = serializeObjectParam({
-                        allowReserved,
+                        allowReserved: options.allowReserved,
                         explode: true,
                         name,
                         style: "deepObject",
                         value: value,
-                        ...object,
+                        ...options.object,
                     });
                     if (serializedObject)
                         search.push(serializedObject);
                 }
                 else {
                     const serializedPrimitive = serializePrimitiveParam({
-                        allowReserved,
+                        allowReserved: options.allowReserved,
                         name,
                         value: value,
                     });
@@ -131,13 +132,20 @@ export const mergeConfigs = (a, b) => {
     config.headers = mergeHeaders(a.headers, b.headers);
     return config;
 };
+const headersEntries = (headers) => {
+    const entries = [];
+    headers.forEach((value, key) => {
+        entries.push([key, value]);
+    });
+    return entries;
+};
 export const mergeHeaders = (...headers) => {
     const mergedHeaders = new Headers();
     for (const header of headers) {
-        if (!header || typeof header !== "object") {
+        if (!header) {
             continue;
         }
-        const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
+        const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
         for (const [key, value] of iterator) {
             if (value === null) {
                 mergedHeaders.delete(key);
@@ -157,47 +165,39 @@ export const mergeHeaders = (...headers) => {
     return mergedHeaders;
 };
 class Interceptors {
-    _fns;
-    constructor() {
-        this._fns = [];
-    }
+    fns = [];
     clear() {
-        this._fns = [];
+        this.fns = [];
     }
-    getInterceptorIndex(id) {
-        if (typeof id === "number") {
-            return this._fns[id] ? id : -1;
-        }
-        else {
-            return this._fns.indexOf(id);
+    eject(id) {
+        const index = this.getInterceptorIndex(id);
+        if (this.fns[index]) {
+            this.fns[index] = null;
         }
     }
     exists(id) {
         const index = this.getInterceptorIndex(id);
-        return !!this._fns[index];
+        return Boolean(this.fns[index]);
     }
-    eject(id) {
-        const index = this.getInterceptorIndex(id);
-        if (this._fns[index]) {
-            this._fns[index] = null;
+    getInterceptorIndex(id) {
+        if (typeof id === "number") {
+            return this.fns[id] ? id : -1;
         }
+        return this.fns.indexOf(id);
     }
     update(id, fn) {
         const index = this.getInterceptorIndex(id);
-        if (this._fns[index]) {
-            this._fns[index] = fn;
+        if (this.fns[index]) {
+            this.fns[index] = fn;
             return id;
         }
-        else {
-            return false;
-        }
+        return false;
     }
     use(fn) {
-        this._fns = [...this._fns, fn];
-        return this._fns.length - 1;
+        this.fns.push(fn);
+        return this.fns.length - 1;
     }
 }
-// do not add `Middleware` as return type so we can use _fns internally
 export const createInterceptors = () => ({
     error: new Interceptors(),
     request: new Interceptors(),

package/dist/gen/client.gen.d.ts

@@ -1,5 +1,5 @@
-import type { ClientOptions } from "./types.gen.js";
-import { type Config, type ClientOptions as DefaultClientOptions } from "./client/index.js";
+import { type ClientOptions, type Config } from "./client/index.js";
+import type { ClientOptions as ClientOptions2 } from "./types.gen.js";
 /**
  * The `createClientConfig()` function will be called on client initialization
  * and the returned object will become the client's initial configuration.
@@ -8,5 +8,5 @@ import { type Config, type ClientOptions as DefaultClientOptions } from "./clien
  * `setConfig()`. This is useful for example if you're using Next.js
  * to ensure your client always has the correct values.
  */
-export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
 export declare const client: import("./client/types.gen.js").Client;

package/dist/gen/client.gen.js

@@ -1,5 +1,3 @@
 // This file is auto-generated by @hey-api/openapi-ts
 import { createClient, createConfig } from "./client/index.js";
-export const client = createClient(createConfig({
-    baseUrl: "http://localhost:4096",
-}));
+export const client = createClient(createConfig({ baseUrl: "http://localhost:4096" }));

package/dist/gen/core/bodySerializer.gen.d.ts

@@ -1,11 +1,18 @@
 import type { ArrayStyle, ObjectStyle, SerializerOptions } from "./pathSerializer.gen.js";
 export type QuerySerializer = (query: Record<string, unknown>) => string;
 export type BodySerializer = (body: any) => any;
-export interface QuerySerializerOptions {
+type QuerySerializerOptionsObject = {
     allowReserved?: boolean;
-    array?: SerializerOptions<ArrayStyle>;
-    object?: SerializerOptions<ObjectStyle>;
-}
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
 export declare const formDataBodySerializer: {
     bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
 };
@@ -15,3 +22,4 @@ export declare const jsonBodySerializer: {
 export declare const urlSearchParamsBodySerializer: {
     bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
 };
+export {};

package/dist/gen/core/params.gen.d.ts

@@ -17,6 +17,16 @@ export type Field = {
      */
     key?: string;
     map?: string;
+} | {
+    /**
+     * Field name. This is the name we want the user to see and use.
+     */
+    key: string;
+    /**
+     * Field mapped name. This is the name we want to use in the request.
+     * If `in` is omitted, `map` aliases `key` to the transport layer.
+     */
+    map: Slot;
 };
 export interface Fields {
     allowExtra?: Partial<Record<Slot, boolean>>;

package/dist/gen/core/params.gen.js

@@ -19,6 +19,11 @@ const buildKeyMap = (fields, map) => {
                 });
             }
         }
+        else if ("key" in config) {
+            map.set(config.key, {
+                map: config.map,
+            });
+        }
         else if (config.args) {
             buildKeyMap(config.args, map);
         }
@@ -52,7 +57,10 @@ export const buildClientParams = (args, fields) => {
             if (config.key) {
                 const field = map.get(config.key);
                 const name = field.map || config.key;
-                params[field.in][name] = arg;
+                if (field.in) {
+                    ;
+                    params[field.in][name] = arg;
+                }
             }
             else {
                 params.body = arg;
@@ -62,8 +70,13 @@ export const buildClientParams = (args, fields) => {
             for (const [key, value] of Object.entries(arg ?? {})) {
                 const field = map.get(key);
                 if (field) {
-                    const name = field.map || key;
-                    params[field.in][name] = value;
+                    if (field.in) {
+                        const name = field.map || key;
+                        params[field.in][name] = value;
+                    }
+                    else {
+                        params[field.map] = value;
+                    }
                 }
                 else {
                     const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
@@ -71,8 +84,8 @@ export const buildClientParams = (args, fields) => {
                         const [prefix, slot] = extra;
                         params[slot][key.slice(prefix.length)] = value;
                     }
-                    else {
-                        for (const [slot, allowed] of Object.entries(config.allowExtra ?? {})) {
+                    else if ("allowExtra" in config && config.allowExtra) {
+                        for (const [slot, allowed] of Object.entries(config.allowExtra)) {
                             if (allowed) {
                                 ;
                                 params[slot][key] = value;

package/dist/gen/core/serverSentEvents.gen.d.ts

@@ -1,5 +1,16 @@
 import type { Config } from "./types.gen.js";
 export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> & Pick<Config, "method" | "responseTransformer" | "responseValidator"> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
     /**
      * Callback invoked when a network or parsing error occurs during streaming.
      *
@@ -17,6 +28,7 @@ export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method
      * @returns Nothing (void).
      */
     onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit["body"];
     /**
      * Default retry delay in milliseconds.
      *
@@ -56,4 +68,4 @@ export interface StreamEvent<TData = unknown> {
 export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-export declare const createSseClient: <TData = unknown>({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;
+export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;