@opencode-ai/sdk 0.1.0-alpha.9 → 0.3.101

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

@@ -0,0 +1,17 @@
+import type { ArrayStyle, ObjectStyle, SerializerOptions } from './pathSerializer';
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+export type BodySerializer = (body: any) => any;
+export interface QuerySerializerOptions {
+    allowReserved?: boolean;
+    array?: SerializerOptions<ArrayStyle>;
+    object?: SerializerOptions<ObjectStyle>;
+}
+export declare const formDataBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
+};
+export declare const jsonBodySerializer: {
+    bodySerializer: <T>(body: T) => string;
+};
+export declare const urlSearchParamsBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
+};

package/dist/gen/core/bodySerializer.js

@@ -0,0 +1,53 @@
+const serializeFormDataPair = (data, key, value) => {
+    if (typeof value === 'string' || value instanceof Blob) {
+        data.append(key, value);
+    }
+    else {
+        data.append(key, JSON.stringify(value));
+    }
+};
+const serializeUrlSearchParamsPair = (data, key, value) => {
+    if (typeof value === 'string') {
+        data.append(key, value);
+    }
+    else {
+        data.append(key, JSON.stringify(value));
+    }
+};
+export const formDataBodySerializer = {
+    bodySerializer: (body) => {
+        const data = new FormData();
+        Object.entries(body).forEach(([key, value]) => {
+            if (value === undefined || value === null) {
+                return;
+            }
+            if (Array.isArray(value)) {
+                value.forEach((v) => serializeFormDataPair(data, key, v));
+            }
+            else {
+                serializeFormDataPair(data, key, value);
+            }
+        });
+        return data;
+    },
+};
+export const jsonBodySerializer = {
+    bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === 'bigint' ? value.toString() : value),
+};
+export const urlSearchParamsBodySerializer = {
+    bodySerializer: (body) => {
+        const data = new URLSearchParams();
+        Object.entries(body).forEach(([key, value]) => {
+            if (value === undefined || value === null) {
+                return;
+            }
+            if (Array.isArray(value)) {
+                value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+            }
+            else {
+                serializeUrlSearchParamsPair(data, key, value);
+            }
+        });
+        return data.toString();
+    },
+};

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

@@ -0,0 +1,33 @@
+type Slot = 'body' | 'headers' | 'path' | 'query';
+export type Field = {
+    in: Exclude<Slot, 'body'>;
+    /**
+     * 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 omitted, we use the same value as `key`.
+     */
+    map?: string;
+} | {
+    in: Extract<Slot, 'body'>;
+    /**
+     * Key isn't required for bodies.
+     */
+    key?: string;
+    map?: string;
+};
+export interface Fields {
+    allowExtra?: Partial<Record<Slot, boolean>>;
+    args?: ReadonlyArray<Field>;
+}
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+interface Params {
+    body: unknown;
+    headers: Record<string, unknown>;
+    path: Record<string, unknown>;
+    query: Record<string, unknown>;
+}
+export declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
+export {};

package/dist/gen/core/params.js

@@ -0,0 +1,87 @@
+const extraPrefixesMap = {
+    $body_: 'body',
+    $headers_: 'headers',
+    $path_: 'path',
+    $query_: 'query',
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+const buildKeyMap = (fields, map) => {
+    if (!map) {
+        map = new Map();
+    }
+    for (const config of fields) {
+        if ('in' in config) {
+            if (config.key) {
+                map.set(config.key, {
+                    in: config.in,
+                    map: config.map,
+                });
+            }
+        }
+        else if (config.args) {
+            buildKeyMap(config.args, map);
+        }
+    }
+    return map;
+};
+const stripEmptySlots = (params) => {
+    for (const [slot, value] of Object.entries(params)) {
+        if (value && typeof value === 'object' && !Object.keys(value).length) {
+            delete params[slot];
+        }
+    }
+};
+export const buildClientParams = (args, fields) => {
+    const params = {
+        body: {},
+        headers: {},
+        path: {},
+        query: {},
+    };
+    const map = buildKeyMap(fields);
+    let config;
+    for (const [index, arg] of args.entries()) {
+        if (fields[index]) {
+            config = fields[index];
+        }
+        if (!config) {
+            continue;
+        }
+        if ('in' in config) {
+            if (config.key) {
+                const field = map.get(config.key);
+                const name = field.map || config.key;
+                params[field.in][name] = arg;
+            }
+            else {
+                params.body = arg;
+            }
+        }
+        else {
+            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;
+                }
+                else {
+                    const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+                    if (extra) {
+                        const [prefix, slot] = extra;
+                        params[slot][key.slice(prefix.length)] = value;
+                    }
+                    else {
+                        for (const [slot, allowed] of Object.entries(config.allowExtra ?? {})) {
+                            if (allowed) {
+                                params[slot][key] = value;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    stripEmptySlots(params);
+    return params;
+};

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

@@ -0,0 +1,33 @@
+interface SerializeOptions<T> extends SerializePrimitiveOptions, SerializerOptions<T> {
+}
+interface SerializePrimitiveOptions {
+    allowReserved?: boolean;
+    name: string;
+}
+export interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = 'label' | 'matrix' | 'simple';
+export type ObjectStyle = 'form' | 'deepObject';
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+    value: string;
+}
+export declare const separatorArrayExplode: (style: ArraySeparatorStyle) => "." | ";" | "," | "&";
+export declare const separatorArrayNoExplode: (style: ArraySeparatorStyle) => "," | "|" | "%20";
+export declare const separatorObjectExplode: (style: ObjectSeparatorStyle) => "." | ";" | "," | "&";
+export declare const serializeArrayParam: ({ allowReserved, explode, name, style, value, }: SerializeOptions<ArraySeparatorStyle> & {
+    value: unknown[];
+}) => string;
+export declare const serializePrimitiveParam: ({ allowReserved, name, value, }: SerializePrimitiveParam) => string;
+export declare const serializeObjectParam: ({ allowReserved, explode, name, style, value, valueOnly, }: SerializeOptions<ObjectSeparatorStyle> & {
+    value: Record<string, unknown> | Date;
+    valueOnly?: boolean;
+}) => string;
+export {};

package/dist/gen/core/pathSerializer.js

@@ -0,0 +1,113 @@
+export const separatorArrayExplode = (style) => {
+    switch (style) {
+        case 'label':
+            return '.';
+        case 'matrix':
+            return ';';
+        case 'simple':
+            return ',';
+        default:
+            return '&';
+    }
+};
+export const separatorArrayNoExplode = (style) => {
+    switch (style) {
+        case 'form':
+            return ',';
+        case 'pipeDelimited':
+            return '|';
+        case 'spaceDelimited':
+            return '%20';
+        default:
+            return ',';
+    }
+};
+export const separatorObjectExplode = (style) => {
+    switch (style) {
+        case 'label':
+            return '.';
+        case 'matrix':
+            return ';';
+        case 'simple':
+            return ',';
+        default:
+            return '&';
+    }
+};
+export const serializeArrayParam = ({ allowReserved, explode, name, style, value, }) => {
+    if (!explode) {
+        const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+        switch (style) {
+            case 'label':
+                return `.${joinedValues}`;
+            case 'matrix':
+                return `;${name}=${joinedValues}`;
+            case 'simple':
+                return joinedValues;
+            default:
+                return `${name}=${joinedValues}`;
+        }
+    }
+    const separator = separatorArrayExplode(style);
+    const joinedValues = value
+        .map((v) => {
+        if (style === 'label' || style === 'simple') {
+            return allowReserved ? v : encodeURIComponent(v);
+        }
+        return serializePrimitiveParam({
+            allowReserved,
+            name,
+            value: v,
+        });
+    })
+        .join(separator);
+    return style === 'label' || style === 'matrix'
+        ? separator + joinedValues
+        : joinedValues;
+};
+export const serializePrimitiveParam = ({ allowReserved, name, value, }) => {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        throw new Error('Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.');
+    }
+    return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+export const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly, }) => {
+    if (value instanceof Date) {
+        return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+    }
+    if (style !== 'deepObject' && !explode) {
+        let values = [];
+        Object.entries(value).forEach(([key, v]) => {
+            values = [
+                ...values,
+                key,
+                allowReserved ? v : encodeURIComponent(v),
+            ];
+        });
+        const joinedValues = values.join(',');
+        switch (style) {
+            case 'form':
+                return `${name}=${joinedValues}`;
+            case 'label':
+                return `.${joinedValues}`;
+            case 'matrix':
+                return `;${name}=${joinedValues}`;
+            default:
+                return joinedValues;
+        }
+    }
+    const separator = separatorObjectExplode(style);
+    const joinedValues = Object.entries(value)
+        .map(([key, v]) => serializePrimitiveParam({
+        allowReserved,
+        name: style === 'deepObject' ? `${name}[${key}]` : key,
+        value: v,
+    }))
+        .join(separator);
+    return style === 'label' || style === 'matrix'
+        ? separator + joinedValues
+        : joinedValues;
+};

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

@@ -0,0 +1,78 @@
+import type { Auth, AuthToken } from './auth';
+import type { BodySerializer, QuerySerializer, QuerySerializerOptions } from './bodySerializer';
+export interface Client<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never> {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    connect: MethodFn;
+    delete: MethodFn;
+    get: MethodFn;
+    getConfig: () => Config;
+    head: MethodFn;
+    options: MethodFn;
+    patch: MethodFn;
+    post: MethodFn;
+    put: MethodFn;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+    trace: MethodFn;
+}
+export interface Config {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never] ? true : [T] extends [never | undefined] ? [undefined] extends [T] ? false : true : false;
+export type OmitNever<T extends Record<string, unknown>> = {
+    [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];
+};
+export {};

package/dist/gen/sdk.gen.d.ts

@@ -0,0 +1,149 @@
+import type { Options as ClientOptions, TDataShape, Client } from './client';
+import type { EventSubscribeData, EventSubscribeResponses, AppGetData, AppGetResponses, AppInitData, AppInitResponses, ConfigGetData, ConfigGetResponses, SessionListData, SessionListResponses, SessionCreateData, SessionCreateResponses, SessionCreateErrors, SessionDeleteData, SessionDeleteResponses, SessionInitData, SessionInitResponses, SessionAbortData, SessionAbortResponses, SessionUnshareData, SessionUnshareResponses, SessionShareData, SessionShareResponses, SessionSummarizeData, SessionSummarizeResponses, SessionMessagesData, SessionMessagesResponses, SessionChatData, SessionChatResponses, SessionRevertData, SessionRevertResponses, SessionUnrevertData, SessionUnrevertResponses, ConfigProvidersData, ConfigProvidersResponses, FindTextData, FindTextResponses, FindFilesData, FindFilesResponses, FindSymbolsData, FindSymbolsResponses, FileReadData, FileReadResponses, FileStatusData, FileStatusResponses, AppLogData, AppLogResponses, AppModesData, AppModesResponses, TuiAppendPromptData, TuiAppendPromptResponses, TuiOpenHelpData, TuiOpenHelpResponses } from './types.gen';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+declare class _HeyApiClient {
+    protected _client: Client;
+    constructor(args?: {
+        client?: Client;
+    });
+}
+declare class Event extends _HeyApiClient {
+    /**
+     * Get events
+     */
+    subscribe<ThrowOnError extends boolean = false>(options?: Options<EventSubscribeData, ThrowOnError>): import("./client").RequestResult<EventSubscribeResponses, unknown, ThrowOnError, "fields">;
+}
+declare class App extends _HeyApiClient {
+    /**
+     * Get app info
+     */
+    get<ThrowOnError extends boolean = false>(options?: Options<AppGetData, ThrowOnError>): import("./client").RequestResult<AppGetResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Initialize the app
+     */
+    init<ThrowOnError extends boolean = false>(options?: Options<AppInitData, ThrowOnError>): import("./client").RequestResult<AppInitResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Write a log entry to the server logs
+     */
+    log<ThrowOnError extends boolean = false>(options?: Options<AppLogData, ThrowOnError>): import("./client").RequestResult<AppLogResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * List all modes
+     */
+    modes<ThrowOnError extends boolean = false>(options?: Options<AppModesData, ThrowOnError>): import("./client").RequestResult<AppModesResponses, unknown, ThrowOnError, "fields">;
+}
+declare class Config extends _HeyApiClient {
+    /**
+     * Get config info
+     */
+    get<ThrowOnError extends boolean = false>(options?: Options<ConfigGetData, ThrowOnError>): import("./client").RequestResult<ConfigGetResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * List all providers
+     */
+    providers<ThrowOnError extends boolean = false>(options?: Options<ConfigProvidersData, ThrowOnError>): import("./client").RequestResult<ConfigProvidersResponses, unknown, ThrowOnError, "fields">;
+}
+declare class Session extends _HeyApiClient {
+    /**
+     * List all sessions
+     */
+    list<ThrowOnError extends boolean = false>(options?: Options<SessionListData, ThrowOnError>): import("./client").RequestResult<SessionListResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Create a new session
+     */
+    create<ThrowOnError extends boolean = false>(options?: Options<SessionCreateData, ThrowOnError>): import("./client").RequestResult<SessionCreateResponses, SessionCreateErrors, ThrowOnError, "fields">;
+    /**
+     * Delete a session and all its data
+     */
+    delete<ThrowOnError extends boolean = false>(options: Options<SessionDeleteData, ThrowOnError>): import("./client").RequestResult<SessionDeleteResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Analyze the app and create an AGENTS.md file
+     */
+    init<ThrowOnError extends boolean = false>(options: Options<SessionInitData, ThrowOnError>): import("./client").RequestResult<SessionInitResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Abort a session
+     */
+    abort<ThrowOnError extends boolean = false>(options: Options<SessionAbortData, ThrowOnError>): import("./client").RequestResult<SessionAbortResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Unshare the session
+     */
+    unshare<ThrowOnError extends boolean = false>(options: Options<SessionUnshareData, ThrowOnError>): import("./client").RequestResult<SessionUnshareResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Share a session
+     */
+    share<ThrowOnError extends boolean = false>(options: Options<SessionShareData, ThrowOnError>): import("./client").RequestResult<SessionShareResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Summarize the session
+     */
+    summarize<ThrowOnError extends boolean = false>(options: Options<SessionSummarizeData, ThrowOnError>): import("./client").RequestResult<SessionSummarizeResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * List messages for a session
+     */
+    messages<ThrowOnError extends boolean = false>(options: Options<SessionMessagesData, ThrowOnError>): import("./client").RequestResult<SessionMessagesResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Create and send a new message to a session
+     */
+    chat<ThrowOnError extends boolean = false>(options: Options<SessionChatData, ThrowOnError>): import("./client").RequestResult<SessionChatResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Revert a message
+     */
+    revert<ThrowOnError extends boolean = false>(options: Options<SessionRevertData, ThrowOnError>): import("./client").RequestResult<SessionRevertResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Restore all reverted messages
+     */
+    unrevert<ThrowOnError extends boolean = false>(options: Options<SessionUnrevertData, ThrowOnError>): import("./client").RequestResult<SessionUnrevertResponses, unknown, ThrowOnError, "fields">;
+}
+declare class Find extends _HeyApiClient {
+    /**
+     * Find text in files
+     */
+    text<ThrowOnError extends boolean = false>(options: Options<FindTextData, ThrowOnError>): import("./client").RequestResult<FindTextResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Find files
+     */
+    files<ThrowOnError extends boolean = false>(options: Options<FindFilesData, ThrowOnError>): import("./client").RequestResult<FindFilesResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Find workspace symbols
+     */
+    symbols<ThrowOnError extends boolean = false>(options: Options<FindSymbolsData, ThrowOnError>): import("./client").RequestResult<FindSymbolsResponses, unknown, ThrowOnError, "fields">;
+}
+declare class File extends _HeyApiClient {
+    /**
+     * Read a file
+     */
+    read<ThrowOnError extends boolean = false>(options: Options<FileReadData, ThrowOnError>): import("./client").RequestResult<FileReadResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Get file status
+     */
+    status<ThrowOnError extends boolean = false>(options?: Options<FileStatusData, ThrowOnError>): import("./client").RequestResult<FileStatusResponses, unknown, ThrowOnError, "fields">;
+}
+declare class Tui extends _HeyApiClient {
+    /**
+     * Append prompt to the TUI
+     */
+    appendPrompt<ThrowOnError extends boolean = false>(options?: Options<TuiAppendPromptData, ThrowOnError>): import("./client").RequestResult<TuiAppendPromptResponses, unknown, ThrowOnError, "fields">;
+    /**
+     * Open the help dialog
+     */
+    openHelp<ThrowOnError extends boolean = false>(options?: Options<TuiOpenHelpData, ThrowOnError>): import("./client").RequestResult<TuiOpenHelpResponses, unknown, ThrowOnError, "fields">;
+}
+export declare class OpencodeClient extends _HeyApiClient {
+    event: Event;
+    app: App;
+    config: Config;
+    session: Session;
+    find: Find;
+    file: File;
+    tui: Tui;
+}
+export {};