@upon-ai/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 UponAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,60 @@
-# Temporary Holding Version
+# @upon-ai/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed Node.js client for the UponAI customer API. MIT © 2026 UponAI.
+Requires Node >=22.14. ESM package; CommonJS consumers can use dynamic `import()`.
+
+## Install
+
+```sh
+npm install @upon-ai/sdk@0.1.0
+```
+
+```ts
+import { UponAI, UponAIError } from '@upon-ai/sdk';
+
+const client = new UponAI({ apiKey: process.env.UPONAI_API_KEY! });
+const workspaces = await client.listWorkspaces();
+const agents = await client.listAgents({ query: { workspaceId: 123, limit: 20 } });
+const agent = await client.getAgent({
+  path: { agentId: 'agent_example' },
+  query: { workspaceId: 123 },
+});
+```
+
+Keep the API key on your server. Do not embed customer credentials in browser
+bundles. Each client keeps its own credential; an async `apiKey` callback can
+supply a rotated token. There are no global credentials or privileged header overrides.
+
+All 75 reviewed public operations have named methods. Inputs use `path`, `query`
+and `body` groups matching the public OpenAPI contract. Types include
+`OperationInput`, `OperationOutput`, `operations` and `components`.
+Multipart bodies use native `FormData`; binary endpoints return `Blob`.
+JSON responses retain the API's native shape, without invented pagination fields.
+
+```ts
+const controller = new AbortController();
+try {
+  await client.getAgent(
+    { path: { agentId: 'agent_example' }, query: { workspaceId: 123 } },
+    { signal: controller.signal, timeoutMs: 15_000 },
+  );
+} catch (error) {
+  if (error instanceof UponAIError) {
+    console.error(error.status, error.requestId);
+  }
+}
+```
+
+Default timeout is 30 seconds. Only GET requests retry HTTP 429/502/503/504,
+up to twice with bounded backoff. Writes and network failures are not automatically
+retried. Redirects are rejected. Responses are capped at 5 MiB; JSON requests
+are capped at 5 MiB. The server applies its own multipart upload limits.
+
+For pagination, `client.paginate({ operation, input, items, next, maxPages })`
+accepts callbacks for the particular endpoint's documented page shape. `next`
+returns the next operation input or `undefined`; repeated inputs and excessive
+pages fail instead of looping indefinitely. No universal cursor format is assumed.
+
+Use `baseUrl` only for a trusted HTTPS API origin, such as your staging deployment.
+The optional injected `fetch` is trusted application code, primarily for tests.
+Types describe the reviewed contract; responses are not runtime schema-validated.

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { ClientOptions, OperationId, OperationInput, OperationOutput, RequestOptions, PaginationOptions } from './types.js';
+export declare class ClientCore {
+    private readonly config;
+    private readonly base;
+    private readonly fetcher;
+    private readonly timeout;
+    private readonly retries;
+    constructor(config: ClientOptions);
+    protected execute<K extends OperationId>(operation: K, args: OperationInput<K>, options?: RequestOptions): Promise<OperationOutput<K>>;
+    paginate<K extends OperationId, T>(options: PaginationOptions<K, T>): AsyncGenerator<T>;
+}

package/dist/client.js

@@ -0,0 +1,194 @@
+import { metadata } from './metadata.js';
+import { UponAIError, UponAIValidationError } from './errors.js';
+const MAX_BYTES = 5 * 1024 * 1024;
+const fail = (message) => { throw new UponAIValidationError(message); };
+function bounded(n, min, max, label) { if (!Number.isInteger(n) || n < min || n > max)
+    fail(`Invalid ${label}`); return n; }
+function validateValue(value, schema, name) {
+    if (schema.type === 'integer' && (!Number.isInteger(value)))
+        fail(`Expected integer: ${name}`);
+    if (schema.type === 'number' && (typeof value !== 'number' || !Number.isFinite(value)))
+        fail(`Expected number: ${name}`);
+    if (schema.type === 'string' && typeof value !== 'string')
+        fail(`Expected string: ${name}`);
+    if (schema.type === 'boolean' && typeof value !== 'boolean')
+        fail(`Expected boolean: ${name}`);
+    if (typeof value === 'number' && ((schema.minimum !== undefined && value < schema.minimum) || (schema.maximum !== undefined && value > schema.maximum)))
+        fail(`Out of range: ${name}`);
+    if (schema.enum && !schema.enum.includes(value))
+        fail(`Invalid value: ${name}`);
+}
+export class ClientCore {
+    config;
+    base;
+    fetcher;
+    timeout;
+    retries;
+    constructor(config) {
+        this.config = config;
+        if (!config || !(typeof config.apiKey === 'string' || typeof config.apiKey === 'function'))
+            fail('apiKey is required');
+        const url = new URL(config.baseUrl || 'https://api.upon-ai.com');
+        if (url.protocol !== 'https:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash)
+            fail('baseUrl must be an HTTPS origin');
+        this.base = url.origin;
+        this.fetcher = config.fetch || globalThis.fetch;
+        this.timeout = bounded(config.timeoutMs ?? 30000, 1, 120000, 'timeout');
+        this.retries = bounded(config.maxRetries ?? 2, 0, 3, 'retry limit');
+    }
+    async execute(operation, args, options = {}) {
+        if (!Object.hasOwn(metadata, operation))
+            fail('Operation is not in the public contract');
+        const meta = metadata[operation], input = (args || {});
+        if (Object.keys(input).some(k => !['path', 'query', 'body'].includes(k)))
+            fail('Only path, query and body inputs are supported');
+        let route = meta.path;
+        const query = new URLSearchParams();
+        for (const location of ['path', 'query']) {
+            const supplied = input[location] || {};
+            if (typeof supplied !== 'object' || Array.isArray(supplied))
+                fail(`Invalid ${location}`);
+            const parameters = meta.parameters.filter((p) => p.in === location);
+            if (Object.keys(supplied).some(k => !parameters.some((p) => p.name === k)))
+                fail(`Unknown ${location} parameter`);
+            for (const p of parameters) {
+                const value = supplied[p.name];
+                if (value === undefined) {
+                    if (p.required)
+                        fail(`Missing ${location} parameter: ${p.name}`);
+                    continue;
+                }
+                validateValue(value, p.schema, p.name);
+                if (location === 'path') {
+                    if (!/^[A-Za-z0-9_-]+$/.test(String(value)))
+                        fail(`Invalid path identifier: ${p.name}`);
+                    route = route.replace(`{${p.name}}`, encodeURIComponent(String(value)));
+                }
+                else if (Array.isArray(value)) {
+                    for (const v of value)
+                        query.append(p.name, String(v));
+                }
+                else if (typeof value === 'object')
+                    fail(`Unsupported query value: ${p.name}`);
+                else
+                    query.set(p.name, String(value));
+            }
+        }
+        if (route.includes('{'))
+            fail('Missing path parameter');
+        if (meta.bodyRequired && input.body === undefined)
+            fail('Request body is required');
+        if (!meta.bodyType && input.body !== undefined)
+            fail('This operation does not accept a body');
+        const headers = { Accept: 'application/json' };
+        let body;
+        if (input.body !== undefined) {
+            if (meta.bodyType === 'multipart/form-data') {
+                if (!(input.body instanceof FormData))
+                    fail('Multipart operations require FormData');
+                body = input.body;
+            }
+            else {
+                body = JSON.stringify(input.body);
+                headers['Content-Type'] = 'application/json';
+                if (Buffer.byteLength(body) > MAX_BYTES)
+                    fail('Request exceeds 5 MiB');
+            }
+        }
+        const token = typeof this.config.apiKey === 'function' ? await this.config.apiKey() : this.config.apiKey;
+        if (!token || /[\s\x00-\x1f\x7f]/.test(token))
+            fail('Invalid API credential');
+        headers.Authorization = `Bearer ${token}`;
+        const url = this.base + route + (query.size ? '?' + query.toString() : '');
+        const timeout = AbortSignal.timeout(bounded(options.timeoutMs ?? this.timeout, 1, 120000, 'timeout'));
+        const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+        const retryable = meta.method === 'get';
+        for (let attempt = 0;; attempt++) {
+            let response;
+            try {
+                response = await this.fetcher(url, { method: meta.method.toUpperCase(), headers, body, redirect: 'error', credentials: 'omit', signal });
+            }
+            catch {
+                if (signal.aborted)
+                    throw new UponAIError('Request cancelled or timed out');
+                throw new UponAIError('Unable to reach the UponAI API');
+            }
+            if (retryable && attempt < this.retries && [429, 502, 503, 504].includes(response.status)) {
+                const retryAfter = response.headers.get('retry-after');
+                const seconds = retryAfter === null ? NaN : Number(retryAfter);
+                const delay = Number.isFinite(seconds) ? Math.min(Math.max(seconds * 1000, 0), 5000) : Math.min(200 * 2 ** attempt, 2000);
+                await response.body?.cancel();
+                await new Promise((resolve, reject) => { if (signal.aborted)
+                    return reject(new UponAIError('Request cancelled or timed out')); const cancel = () => { clearTimeout(timer); reject(new UponAIError('Request cancelled or timed out')); }; const timer = setTimeout(() => { signal.removeEventListener('abort', cancel); resolve(); }, delay); signal.addEventListener('abort', cancel, { once: true }); });
+                continue;
+            }
+            if (!response.ok) {
+                await response.body?.cancel();
+                const id = response.headers.get('x-request-id');
+                throw new UponAIError(`UponAI API returned HTTP ${response.status}`, response.status, id && /^[\w-]{1,128}$/.test(id) ? id : undefined);
+            }
+            if (response.status === 204)
+                return undefined;
+            const contentLength = Number(response.headers.get('content-length'));
+            if (contentLength > MAX_BYTES) {
+                await response.body?.cancel();
+                throw new UponAIError('Response exceeds 5 MiB');
+            }
+            const chunks = [];
+            let size = 0;
+            const reader = response.body?.getReader();
+            if (reader) {
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        size += value.byteLength;
+                        if (size > MAX_BYTES) {
+                            await reader.cancel();
+                            throw new UponAIError('Response exceeds 5 MiB');
+                        }
+                        chunks.push(value);
+                    }
+                }
+                catch (e) {
+                    if (e instanceof UponAIError)
+                        throw e;
+                    throw new UponAIError('Response interrupted');
+                }
+            }
+            const bytes = Buffer.concat(chunks);
+            const contentType = response.headers.get('content-type') || '';
+            if (contentType.includes('json')) {
+                try {
+                    return JSON.parse(bytes.toString('utf8'));
+                }
+                catch {
+                    throw new UponAIError('Invalid JSON response');
+                }
+            }
+            return new Blob([bytes], { type: contentType });
+        }
+    }
+    async *paginate(options) {
+        if (!Object.hasOwn(metadata, options.operation) || metadata[options.operation].method !== 'get')
+            fail('Pagination supports GET operations only');
+        const max = bounded(options.maxPages ?? 100, 1, 1000, 'page limit');
+        let input = options.input;
+        const seen = new Set();
+        for (let i = 0; i < max; i++) {
+            const key = JSON.stringify(input);
+            if (seen.has(key))
+                throw new UponAIError('Pagination cursor repeated');
+            seen.add(key);
+            const page = await this.execute(options.operation, input, { signal: options.signal });
+            for (const item of options.items(page))
+                yield item;
+            const next = options.next(page, input);
+            if (!next)
+                return;
+            input = next;
+        }
+        throw new UponAIError('Pagination page limit reached');
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class UponAIError extends Error {
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    constructor(message: string, status?: number | undefined, requestId?: string | undefined);
+}
+export declare class UponAIValidationError extends UponAIError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,13 @@
+export class UponAIError extends Error {
+    status;
+    requestId;
+    constructor(message, status, requestId) {
+        super(message);
+        this.status = status;
+        this.requestId = requestId;
+        this.name = 'UponAIError';
+    }
+}
+export class UponAIValidationError extends UponAIError {
+    constructor(message) { super(message); this.name = 'UponAIValidationError'; }
+}

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { ClientCore } from './client.js';
+import type { OperationInput, OperationOutput, RequestOptions } from './types.js';
+export * from './types.js';
+export * from './errors.js';
+export type { paths, components, operations } from './schema.js';
+export { publicContractSha256 } from './version.js';
+export declare class UponAI extends ClientCore {
+    listLlms(args: OperationInput<'listLlms'>, options?: RequestOptions): Promise<OperationOutput<'listLlms'>>;
+    createLlm(args: OperationInput<'createLlm'>, options?: RequestOptions): Promise<OperationOutput<'createLlm'>>;
+    getLlm(args: OperationInput<'getLlm'>, options?: RequestOptions): Promise<OperationOutput<'getLlm'>>;
+    updateLlm(args: OperationInput<'updateLlm'>, options?: RequestOptions): Promise<OperationOutput<'updateLlm'>>;
+    deleteLlm(args: OperationInput<'deleteLlm'>, options?: RequestOptions): Promise<OperationOutput<'deleteLlm'>>;
+    listAgents(args: OperationInput<'listAgents'>, options?: RequestOptions): Promise<OperationOutput<'listAgents'>>;
+    createAgent(args: OperationInput<'createAgent'>, options?: RequestOptions): Promise<OperationOutput<'createAgent'>>;
+    getAgent(args: OperationInput<'getAgent'>, options?: RequestOptions): Promise<OperationOutput<'getAgent'>>;
+    updateAgent(args: OperationInput<'updateAgent'>, options?: RequestOptions): Promise<OperationOutput<'updateAgent'>>;
+    deleteAgent(args: OperationInput<'deleteAgent'>, options?: RequestOptions): Promise<OperationOutput<'deleteAgent'>>;
+    listAgentVersions(args: OperationInput<'listAgentVersions'>, options?: RequestOptions): Promise<OperationOutput<'listAgentVersions'>>;
+    createAgentDraftVersion(args: OperationInput<'createAgentDraftVersion'>, options?: RequestOptions): Promise<OperationOutput<'createAgentDraftVersion'>>;
+    publishAgentVersion(args: OperationInput<'publishAgentVersion'>, options?: RequestOptions): Promise<OperationOutput<'publishAgentVersion'>>;
+    deleteAgentVersion(args: OperationInput<'deleteAgentVersion'>, options?: RequestOptions): Promise<OperationOutput<'deleteAgentVersion'>>;
+    listChatAgents(args: OperationInput<'listChatAgents'>, options?: RequestOptions): Promise<OperationOutput<'listChatAgents'>>;
+    createChatAgent(args: OperationInput<'createChatAgent'>, options?: RequestOptions): Promise<OperationOutput<'createChatAgent'>>;
+    getChatAgent(args: OperationInput<'getChatAgent'>, options?: RequestOptions): Promise<OperationOutput<'getChatAgent'>>;
+    updateChatAgent(args: OperationInput<'updateChatAgent'>, options?: RequestOptions): Promise<OperationOutput<'updateChatAgent'>>;
+    deleteChatAgent(args: OperationInput<'deleteChatAgent'>, options?: RequestOptions): Promise<OperationOutput<'deleteChatAgent'>>;
+    listChatAgentVersions(args: OperationInput<'listChatAgentVersions'>, options?: RequestOptions): Promise<OperationOutput<'listChatAgentVersions'>>;
+    createChatAgentDraftVersion(args: OperationInput<'createChatAgentDraftVersion'>, options?: RequestOptions): Promise<OperationOutput<'createChatAgentDraftVersion'>>;
+    publishChatAgentVersion(args: OperationInput<'publishChatAgentVersion'>, options?: RequestOptions): Promise<OperationOutput<'publishChatAgentVersion'>>;
+    deleteChatAgentVersion(args: OperationInput<'deleteChatAgentVersion'>, options?: RequestOptions): Promise<OperationOutput<'deleteChatAgentVersion'>>;
+    publishChatAgentVersionFiltered(args: OperationInput<'publishChatAgentVersionFiltered'>, options?: RequestOptions): Promise<OperationOutput<'publishChatAgentVersionFiltered'>>;
+    listChats(args: OperationInput<'listChats'>, options?: RequestOptions): Promise<OperationOutput<'listChats'>>;
+    createChat(args: OperationInput<'createChat'>, options?: RequestOptions): Promise<OperationOutput<'createChat'>>;
+    createOutboundSmsChat(args: OperationInput<'createOutboundSmsChat'>, options?: RequestOptions): Promise<OperationOutput<'createOutboundSmsChat'>>;
+    getChat(args: OperationInput<'getChat'>, options?: RequestOptions): Promise<OperationOutput<'getChat'>>;
+    updateChat(args: OperationInput<'updateChat'>, options?: RequestOptions): Promise<OperationOutput<'updateChat'>>;
+    createChatCompletion(args: OperationInput<'createChatCompletion'>, options?: RequestOptions): Promise<OperationOutput<'createChatCompletion'>>;
+    endChat(args: OperationInput<'endChat'>, options?: RequestOptions): Promise<OperationOutput<'endChat'>>;
+    listChatWidgets(args: OperationInput<'listChatWidgets'>, options?: RequestOptions): Promise<OperationOutput<'listChatWidgets'>>;
+    createChatWidget(args: OperationInput<'createChatWidget'>, options?: RequestOptions): Promise<OperationOutput<'createChatWidget'>>;
+    getChatWidget(args: OperationInput<'getChatWidget'>, options?: RequestOptions): Promise<OperationOutput<'getChatWidget'>>;
+    updateChatWidget(args: OperationInput<'updateChatWidget'>, options?: RequestOptions): Promise<OperationOutput<'updateChatWidget'>>;
+    regenerateWidgetKey(args: OperationInput<'regenerateWidgetKey'>, options?: RequestOptions): Promise<OperationOutput<'regenerateWidgetKey'>>;
+    listConversationFlows(args: OperationInput<'listConversationFlows'>, options?: RequestOptions): Promise<OperationOutput<'listConversationFlows'>>;
+    createConversationFlow(args: OperationInput<'createConversationFlow'>, options?: RequestOptions): Promise<OperationOutput<'createConversationFlow'>>;
+    getConversationFlow(args: OperationInput<'getConversationFlow'>, options?: RequestOptions): Promise<OperationOutput<'getConversationFlow'>>;
+    updateConversationFlow(args: OperationInput<'updateConversationFlow'>, options?: RequestOptions): Promise<OperationOutput<'updateConversationFlow'>>;
+    deleteConversationFlow(args: OperationInput<'deleteConversationFlow'>, options?: RequestOptions): Promise<OperationOutput<'deleteConversationFlow'>>;
+    listKnowledgeBases(args: OperationInput<'listKnowledgeBases'>, options?: RequestOptions): Promise<OperationOutput<'listKnowledgeBases'>>;
+    createKnowledgeBase(args: OperationInput<'createKnowledgeBase'>, options?: RequestOptions): Promise<OperationOutput<'createKnowledgeBase'>>;
+    getKnowledgeBase(args: OperationInput<'getKnowledgeBase'>, options?: RequestOptions): Promise<OperationOutput<'getKnowledgeBase'>>;
+    deleteKnowledgeBase(args: OperationInput<'deleteKnowledgeBase'>, options?: RequestOptions): Promise<OperationOutput<'deleteKnowledgeBase'>>;
+    addKnowledgeBaseSources(args: OperationInput<'addKnowledgeBaseSources'>, options?: RequestOptions): Promise<OperationOutput<'addKnowledgeBaseSources'>>;
+    deleteKnowledgeBaseSource(args: OperationInput<'deleteKnowledgeBaseSource'>, options?: RequestOptions): Promise<OperationOutput<'deleteKnowledgeBaseSource'>>;
+    listVoices(args: OperationInput<'listVoices'>, options?: RequestOptions): Promise<OperationOutput<'listVoices'>>;
+    searchCommunityVoices(args: OperationInput<'searchCommunityVoices'>, options?: RequestOptions): Promise<OperationOutput<'searchCommunityVoices'>>;
+    addCommunityVoice(args: OperationInput<'addCommunityVoice'>, options?: RequestOptions): Promise<OperationOutput<'addCommunityVoice'>>;
+    cloneVoice(args: OperationInput<'cloneVoice'>, options?: RequestOptions): Promise<OperationOutput<'cloneVoice'>>;
+    getVoice(args: OperationInput<'getVoice'>, options?: RequestOptions): Promise<OperationOutput<'getVoice'>>;
+    streamVoiceSample(args: OperationInput<'streamVoiceSample'>, options?: RequestOptions): Promise<OperationOutput<'streamVoiceSample'>>;
+    listTestCaseDefinitions(args: OperationInput<'listTestCaseDefinitions'>, options?: RequestOptions): Promise<OperationOutput<'listTestCaseDefinitions'>>;
+    createTestCaseDefinition(args: OperationInput<'createTestCaseDefinition'>, options?: RequestOptions): Promise<OperationOutput<'createTestCaseDefinition'>>;
+    listBatchTests(args: OperationInput<'listBatchTests'>, options?: RequestOptions): Promise<OperationOutput<'listBatchTests'>>;
+    createBatchTest(args: OperationInput<'createBatchTest'>, options?: RequestOptions): Promise<OperationOutput<'createBatchTest'>>;
+    getBatchTest(args: OperationInput<'getBatchTest'>, options?: RequestOptions): Promise<OperationOutput<'getBatchTest'>>;
+    getTestCaseDefinition(args: OperationInput<'getTestCaseDefinition'>, options?: RequestOptions): Promise<OperationOutput<'getTestCaseDefinition'>>;
+    updateTestCaseDefinition(args: OperationInput<'updateTestCaseDefinition'>, options?: RequestOptions): Promise<OperationOutput<'updateTestCaseDefinition'>>;
+    deleteTestCaseDefinition(args: OperationInput<'deleteTestCaseDefinition'>, options?: RequestOptions): Promise<OperationOutput<'deleteTestCaseDefinition'>>;
+    getTestRun(args: OperationInput<'getTestRun'>, options?: RequestOptions): Promise<OperationOutput<'getTestRun'>>;
+    listTestRunsByBatch(args: OperationInput<'listTestRunsByBatch'>, options?: RequestOptions): Promise<OperationOutput<'listTestRunsByBatch'>>;
+    getConcurrency(args: OperationInput<'getConcurrency'>, options?: RequestOptions): Promise<OperationOutput<'getConcurrency'>>;
+    listWorkspaces(args?: OperationInput<'listWorkspaces'>, options?: RequestOptions): Promise<OperationOutput<'listWorkspaces'>>;
+    createPhoneCall(args: OperationInput<'createPhoneCall'>, options?: RequestOptions): Promise<OperationOutput<'createPhoneCall'>>;
+    createWebCall(args: OperationInput<'createWebCall'>, options?: RequestOptions): Promise<OperationOutput<'createWebCall'>>;
+    listCalls(args?: OperationInput<'listCalls'>, options?: RequestOptions): Promise<OperationOutput<'listCalls'>>;
+    listCallsFiltered(args?: OperationInput<'listCallsFiltered'>, options?: RequestOptions): Promise<OperationOutput<'listCallsFiltered'>>;
+    fetchCallHistory(args: OperationInput<'fetchCallHistory'>, options?: RequestOptions): Promise<OperationOutput<'fetchCallHistory'>>;
+    getCall(args: OperationInput<'getCall'>, options?: RequestOptions): Promise<OperationOutput<'getCall'>>;
+    updateCall(args: OperationInput<'updateCall'>, options?: RequestOptions): Promise<OperationOutput<'updateCall'>>;
+    endLiveCall(args: OperationInput<'endLiveCall'>, options?: RequestOptions): Promise<OperationOutput<'endLiveCall'>>;
+    updateLiveCall(args: OperationInput<'updateLiveCall'>, options?: RequestOptions): Promise<OperationOutput<'updateLiveCall'>>;
+    rerunCallAnalysis(args: OperationInput<'rerunCallAnalysis'>, options?: RequestOptions): Promise<OperationOutput<'rerunCallAnalysis'>>;
+}

package/dist/index.js

@@ -0,0 +1,82 @@
+// Generated; edit the generator, not this file.
+import { ClientCore } from './client.js';
+export * from './types.js';
+export * from './errors.js';
+export { publicContractSha256 } from './version.js';
+export class UponAI extends ClientCore {
+    listLlms(args, options) { return this.execute('listLlms', args, options); }
+    createLlm(args, options) { return this.execute('createLlm', args, options); }
+    getLlm(args, options) { return this.execute('getLlm', args, options); }
+    updateLlm(args, options) { return this.execute('updateLlm', args, options); }
+    deleteLlm(args, options) { return this.execute('deleteLlm', args, options); }
+    listAgents(args, options) { return this.execute('listAgents', args, options); }
+    createAgent(args, options) { return this.execute('createAgent', args, options); }
+    getAgent(args, options) { return this.execute('getAgent', args, options); }
+    updateAgent(args, options) { return this.execute('updateAgent', args, options); }
+    deleteAgent(args, options) { return this.execute('deleteAgent', args, options); }
+    listAgentVersions(args, options) { return this.execute('listAgentVersions', args, options); }
+    createAgentDraftVersion(args, options) { return this.execute('createAgentDraftVersion', args, options); }
+    publishAgentVersion(args, options) { return this.execute('publishAgentVersion', args, options); }
+    deleteAgentVersion(args, options) { return this.execute('deleteAgentVersion', args, options); }
+    listChatAgents(args, options) { return this.execute('listChatAgents', args, options); }
+    createChatAgent(args, options) { return this.execute('createChatAgent', args, options); }
+    getChatAgent(args, options) { return this.execute('getChatAgent', args, options); }
+    updateChatAgent(args, options) { return this.execute('updateChatAgent', args, options); }
+    deleteChatAgent(args, options) { return this.execute('deleteChatAgent', args, options); }
+    listChatAgentVersions(args, options) { return this.execute('listChatAgentVersions', args, options); }
+    createChatAgentDraftVersion(args, options) { return this.execute('createChatAgentDraftVersion', args, options); }
+    publishChatAgentVersion(args, options) { return this.execute('publishChatAgentVersion', args, options); }
+    deleteChatAgentVersion(args, options) { return this.execute('deleteChatAgentVersion', args, options); }
+    publishChatAgentVersionFiltered(args, options) { return this.execute('publishChatAgentVersionFiltered', args, options); }
+    listChats(args, options) { return this.execute('listChats', args, options); }
+    createChat(args, options) { return this.execute('createChat', args, options); }
+    createOutboundSmsChat(args, options) { return this.execute('createOutboundSmsChat', args, options); }
+    getChat(args, options) { return this.execute('getChat', args, options); }
+    updateChat(args, options) { return this.execute('updateChat', args, options); }
+    createChatCompletion(args, options) { return this.execute('createChatCompletion', args, options); }
+    endChat(args, options) { return this.execute('endChat', args, options); }
+    listChatWidgets(args, options) { return this.execute('listChatWidgets', args, options); }
+    createChatWidget(args, options) { return this.execute('createChatWidget', args, options); }
+    getChatWidget(args, options) { return this.execute('getChatWidget', args, options); }
+    updateChatWidget(args, options) { return this.execute('updateChatWidget', args, options); }
+    regenerateWidgetKey(args, options) { return this.execute('regenerateWidgetKey', args, options); }
+    listConversationFlows(args, options) { return this.execute('listConversationFlows', args, options); }
+    createConversationFlow(args, options) { return this.execute('createConversationFlow', args, options); }
+    getConversationFlow(args, options) { return this.execute('getConversationFlow', args, options); }
+    updateConversationFlow(args, options) { return this.execute('updateConversationFlow', args, options); }
+    deleteConversationFlow(args, options) { return this.execute('deleteConversationFlow', args, options); }
+    listKnowledgeBases(args, options) { return this.execute('listKnowledgeBases', args, options); }
+    createKnowledgeBase(args, options) { return this.execute('createKnowledgeBase', args, options); }
+    getKnowledgeBase(args, options) { return this.execute('getKnowledgeBase', args, options); }
+    deleteKnowledgeBase(args, options) { return this.execute('deleteKnowledgeBase', args, options); }
+    addKnowledgeBaseSources(args, options) { return this.execute('addKnowledgeBaseSources', args, options); }
+    deleteKnowledgeBaseSource(args, options) { return this.execute('deleteKnowledgeBaseSource', args, options); }
+    listVoices(args, options) { return this.execute('listVoices', args, options); }
+    searchCommunityVoices(args, options) { return this.execute('searchCommunityVoices', args, options); }
+    addCommunityVoice(args, options) { return this.execute('addCommunityVoice', args, options); }
+    cloneVoice(args, options) { return this.execute('cloneVoice', args, options); }
+    getVoice(args, options) { return this.execute('getVoice', args, options); }
+    streamVoiceSample(args, options) { return this.execute('streamVoiceSample', args, options); }
+    listTestCaseDefinitions(args, options) { return this.execute('listTestCaseDefinitions', args, options); }
+    createTestCaseDefinition(args, options) { return this.execute('createTestCaseDefinition', args, options); }
+    listBatchTests(args, options) { return this.execute('listBatchTests', args, options); }
+    createBatchTest(args, options) { return this.execute('createBatchTest', args, options); }
+    getBatchTest(args, options) { return this.execute('getBatchTest', args, options); }
+    getTestCaseDefinition(args, options) { return this.execute('getTestCaseDefinition', args, options); }
+    updateTestCaseDefinition(args, options) { return this.execute('updateTestCaseDefinition', args, options); }
+    deleteTestCaseDefinition(args, options) { return this.execute('deleteTestCaseDefinition', args, options); }
+    getTestRun(args, options) { return this.execute('getTestRun', args, options); }
+    listTestRunsByBatch(args, options) { return this.execute('listTestRunsByBatch', args, options); }
+    getConcurrency(args, options) { return this.execute('getConcurrency', args, options); }
+    listWorkspaces(args = {}, options) { return this.execute('listWorkspaces', args, options); }
+    createPhoneCall(args, options) { return this.execute('createPhoneCall', args, options); }
+    createWebCall(args, options) { return this.execute('createWebCall', args, options); }
+    listCalls(args = {}, options) { return this.execute('listCalls', args, options); }
+    listCallsFiltered(args = {}, options) { return this.execute('listCallsFiltered', args, options); }
+    fetchCallHistory(args, options) { return this.execute('fetchCallHistory', args, options); }
+    getCall(args, options) { return this.execute('getCall', args, options); }
+    updateCall(args, options) { return this.execute('updateCall', args, options); }
+    endLiveCall(args, options) { return this.execute('endLiveCall', args, options); }
+    updateLiveCall(args, options) { return this.execute('updateLiveCall', args, options); }
+    rerunCallAnalysis(args, options) { return this.execute('rerunCallAnalysis', args, options); }
+}