@smoothbuilder/smoothagent-agent-server 0.0.0-stage → 0.3.0

package/dist/types/sdk/generated/ts-client/core/stream/Stream.d.ts

@@ -0,0 +1,103 @@
+export declare namespace Stream {
+    interface Args {
+        /**
+         * The HTTP response stream to read from.
+         */
+        stream: ReadableStream;
+        /**
+         * The event shape to use for parsing the stream data.
+         */
+        eventShape: JsonEvent | SseEvent;
+        /**
+         * An abort signal to stop the stream.
+         */
+        signal?: AbortSignal;
+        /**
+         * Whether transparent mid-stream reconnection is enabled on resumable
+         * SSE endpoints. Defaults to true. Has no effect on non-resumable endpoints.
+         */
+        reconnectionEnabled?: boolean;
+        /**
+         * Maximum number of consecutive failed reconnect attempts on resumable SSE
+         * endpoints before giving up. The counter resets to zero each time a
+         * reconnected stream successfully yields at least one event (i.e. makes
+         * progress). Has no effect on non-resumable endpoints.
+         */
+        maxReconnectionAttempts?: number;
+        /**
+         * A function that re-issues the HTTP request with the Last-Event-ID header
+         * and returns the new response body stream. Required for reconnection to work.
+         */
+        reconnect?: (lastEventId: string) => Promise<ReadableStream>;
+    }
+    interface JsonEvent {
+        type: "json";
+        messageTerminator: string;
+    }
+    interface SseEvent {
+        type: "sse";
+        streamTerminator?: string;
+        eventDiscriminator?: string;
+        /** Event names whose union variant wraps the `data:` payload as `{ <eventDiscriminator>, data }`. */
+        envelopeEvents?: string[];
+        resumable?: boolean;
+    }
+}
+export interface ServerSentEvent<T> {
+    data: T;
+    id?: string;
+    retry?: number;
+    event?: string;
+}
+export declare class Stream<T> implements AsyncIterable<T> {
+    private stream;
+    private parse;
+    /**
+     * The prefix to use for each message. For example,
+     * for SSE, the prefix is "data: ".
+     */
+    private prefix;
+    private messageTerminator;
+    private streamTerminator;
+    private eventDiscriminator;
+    private envelopeEvents;
+    private resumable;
+    private reconnectionEnabled;
+    private maxReconnectionAttempts;
+    private reconnect;
+    private controller;
+    private decoder;
+    private externalSignal;
+    private onExternalAbort;
+    constructor({ stream, parse, eventShape, signal, reconnectionEnabled, maxReconnectionAttempts, reconnect, }: Stream.Args & {
+        parse: (val: unknown) => Promise<T>;
+    });
+    private iterMessages;
+    private iterDataMessages;
+    private iterSseEvents;
+    /**
+     * Parses and returns a single SSE event, or returns null if the event is a stream terminator.
+     */
+    private dispatchSseEvent;
+    /**
+     * Determines whether a reconnection attempt should be made.
+     */
+    private shouldReconnect;
+    /**
+     * Delays before reconnecting, using a server-sent retry directive if provided
+     * (clamped to MAX_RECONNECT_DELAY_MS), otherwise falling back to
+     * DEFAULT_RECONNECT_DELAY_MS. The delay is abortable: if the stream's abort
+     * signal fires during the wait, the promise resolves immediately.
+     */
+    private delayReconnect;
+    private createEmptyStream;
+    private removeAbortListener;
+    withMetadata(): AsyncIterable<ServerSentEvent<T>>;
+    private injectDiscriminator;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, unknown>;
+    private decodeChunk;
+}
+/**
+ * Browser polyfill for ReadableStream
+ */
+export declare function readableStreamAsyncIterable<T>(stream: any): AsyncIterableIterator<T>;

package/dist/types/sdk/generated/ts-client/core/stream/index.d.ts

@@ -0,0 +1,2 @@
+export type { ServerSentEvent } from "./Stream.js";
+export { Stream } from "./Stream.js";

package/dist/types/sdk/generated/ts-client/core/url/QueryStringBuilder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+export declare function queryBuilder(): QueryStringBuilder;
+declare class QueryStringBuilder {
+    private parts;
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key: string, value: unknown, options?: {
+        style?: "comma";
+    }): this;
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params: Record<string, unknown>): this;
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams?: Record<string, unknown>): this;
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build(): string;
+}
+export {};

package/dist/types/sdk/generated/ts-client/core/url/encodePathParam.d.ts

@@ -0,0 +1,3 @@
+export declare function encodePathParam(param: unknown, InvalidPathParameterError?: new (args: {
+    message: string;
+}) => Error): string;

package/dist/types/sdk/generated/ts-client/core/url/index.d.ts

@@ -0,0 +1,4 @@
+export { encodePathParam } from "./encodePathParam.js";
+export { join } from "./join.js";
+export { queryBuilder } from "./QueryStringBuilder.js";
+export { toQueryString } from "./qs.js";

package/dist/types/sdk/generated/ts-client/core/url/join.d.ts

@@ -0,0 +1 @@
+export declare function join(base: string, ...segments: string[]): string;

package/dist/types/sdk/generated/ts-client/core/url/qs.d.ts

@@ -0,0 +1,7 @@
+type ArrayFormat = "indices" | "repeat" | "comma";
+interface QueryStringOptions {
+    arrayFormat?: ArrayFormat;
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};

package/dist/types/sdk/generated/ts-client/core/utils/index.d.ts

@@ -0,0 +1 @@
+export { setObjectProperty } from "./setObjectProperty.js";

package/dist/types/sdk/generated/ts-client/core/utils/setObjectProperty.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a copy of object with the value at path set. If a portion of path doesn’t exist it’s created.
+ * Each object along path is shallow-copied, so the original object (and any nested objects it
+ * shares with the copy) is never modified. This is inspired by Lodash's set function, but is
+ * simplified to accommodate our use case. For more details, see https://lodash.com/docs/4.17.15#set.
+ *
+ * @param object The object to copy.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns the updated copy of object.
+ */
+export declare function setObjectProperty<T extends object>(object: T, path: string, value: any): T;

package/dist/types/sdk/generated/ts-client/errors/SmoothAgentApiError.d.ts

@@ -0,0 +1,15 @@
+import type * as core from "../core/index.js";
+export declare class SmoothAgentApiError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    readonly rawResponse?: core.RawResponse;
+    readonly cause?: unknown;
+    constructor({ message, statusCode, body, rawResponse, cause, }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+        rawResponse?: core.RawResponse;
+        cause?: unknown;
+    });
+    get requestId(): string | undefined;
+}

package/dist/types/sdk/generated/ts-client/errors/SmoothAgentApiTimeoutError.d.ts

@@ -0,0 +1,6 @@
+import * as errors from "./index.js";
+export declare class SmoothAgentApiTimeoutError extends errors.SmoothAgentApiError {
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+}

package/dist/types/sdk/generated/ts-client/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { SmoothAgentApiError } from "./SmoothAgentApiError.js";
+export { SmoothAgentApiTimeoutError } from "./SmoothAgentApiTimeoutError.js";

package/dist/types/sdk/generated/ts-dashboard/BaseClient.d.ts

@@ -0,0 +1,54 @@
+import { BearerAuthProvider } from "./auth/BearerAuthProvider.js";
+import * as core from "./core/index.js";
+import type * as environments from "./environments.js";
+export type AuthOption = false | core.AuthProvider["getAuthRequest"] | core.AuthProvider | BearerAuthProvider.AuthOptions;
+export type BaseClientOptions = {
+    environment?: core.Supplier<environments.SmoothAgentDashboardEnvironment | string>;
+    /** Specify a custom URL to connect the client to. */
+    baseUrl?: core.Supplier<string>;
+    /** Additional headers to include in requests. */
+    headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
+    /** The default maximum time to wait for a response in seconds. */
+    timeoutInSeconds?: number;
+    /** The default number of times to retry the request. Defaults to 2. */
+    maxRetries?: number;
+    /** Provide a custom fetch implementation. Useful for platforms that don't have a built-in fetch or need a custom implementation. */
+    fetch?: typeof fetch;
+    /** Configure logging for the client. */
+    logging?: core.logging.LogConfig | core.logging.Logger;
+    /** Default options for SSE stream reconnection behavior. Has no effect on non-resumable endpoints. */
+    stream?: {
+        reconnectionEnabled?: boolean;
+        maxReconnectionAttempts?: number;
+    };
+    /** Override auth. Pass false to disable, a function returning auth headers, an AuthProvider, or auth options. */
+    auth?: AuthOption;
+} & BearerAuthProvider.AuthOptions;
+export interface BaseRequestOptions {
+    /** The maximum time to wait for a response in seconds. */
+    timeoutInSeconds?: number;
+    /** The number of times to retry the request. Defaults to 2. */
+    maxRetries?: number;
+    /** A hook to abort the request. */
+    abortSignal?: AbortSignal;
+    /** Additional query string parameters to include in the request. */
+    queryParams?: Record<string, unknown>;
+    /** A dictionary containing additional parameters to spread into the request's body. */
+    additionalBodyParameters?: Record<string, unknown>;
+    /** Additional headers to include in the request. */
+    headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
+    /** Options for SSE stream reconnection behavior. Has no effect on non-resumable endpoints. */
+    stream?: {
+        reconnectionEnabled?: boolean;
+        maxReconnectionAttempts?: number;
+    };
+}
+export type NormalizedClientOptions<T extends BaseClientOptions = BaseClientOptions> = T & {
+    logging: core.logging.Logger;
+    authProvider?: core.AuthProvider;
+};
+export type NormalizedClientOptionsWithAuth<T extends BaseClientOptions = BaseClientOptions> = NormalizedClientOptions<T> & {
+    authProvider: core.AuthProvider;
+};
+export declare function normalizeClientOptions<T extends BaseClientOptions = BaseClientOptions>(options: T): NormalizedClientOptions<T>;
+export declare function normalizeClientOptionsWithAuth<T extends BaseClientOptions = BaseClientOptions>(options: T): NormalizedClientOptionsWithAuth<T>;