@wabot-dev/framework 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/src/node_modules/@anthropic-ai/sdk/resources/beta/files.js

@@ -0,0 +1,120 @@
+import { APIResource } from '../../core/resource.js';
+import { Page } from '../../core/pagination.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { multipartFormRequestOptions } from '../../internal/uploads.js';
+import { path } from '../../internal/utils/path.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Files extends APIResource {
+    /**
+     * List Files
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const fileMetadata of client.beta.files.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(params = {}, options) {
+        const { betas, ...query } = params ?? {};
+        return this._client.getAPIList('/v1/files', (Page), {
+            query,
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Delete File
+     *
+     * @example
+     * ```ts
+     * const deletedFile = await client.beta.files.delete(
+     *   'file_id',
+     * );
+     * ```
+     */
+    delete(fileID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.delete(path `/v1/files/${fileID}`, {
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Download File
+     *
+     * @example
+     * ```ts
+     * const response = await client.beta.files.download(
+     *   'file_id',
+     * );
+     *
+     * const content = await response.blob();
+     * console.log(content);
+     * ```
+     */
+    download(fileID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get(path `/v1/files/${fileID}/content`, {
+            ...options,
+            headers: buildHeaders([
+                {
+                    'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString(),
+                    Accept: 'application/binary',
+                },
+                options?.headers,
+            ]),
+            __binaryResponse: true,
+        });
+    }
+    /**
+     * Get File Metadata
+     *
+     * @example
+     * ```ts
+     * const fileMetadata =
+     *   await client.beta.files.retrieveMetadata('file_id');
+     * ```
+     */
+    retrieveMetadata(fileID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get(path `/v1/files/${fileID}`, {
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Upload File
+     *
+     * @example
+     * ```ts
+     * const fileMetadata = await client.beta.files.upload({
+     *   file: fs.createReadStream('path/to/file'),
+     * });
+     * ```
+     */
+    upload(params, options) {
+        const { betas, ...body } = params;
+        return this._client.post('/v1/files', multipartFormRequestOptions({
+            body,
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() },
+                options?.headers,
+            ]),
+        }, this._client));
+    }
+}
+
+export { Files };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/beta/messages/batches.js

@@ -0,0 +1,202 @@
+import { APIResource } from '../../../core/resource.js';
+import { Page } from '../../../core/pagination.js';
+import { buildHeaders } from '../../../internal/headers.js';
+import { JSONLDecoder } from '../../../internal/decoders/jsonl.js';
+import { AnthropicError } from '../../../core/error.js';
+import { path } from '../../../internal/utils/path.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Batches extends APIResource {
+    /**
+     * Send a batch of Message creation requests.
+     *
+     * The Message Batches API can be used to process multiple Messages API requests at
+     * once. Once a Message Batch is created, it begins processing immediately. Batches
+     * can take up to 24 hours to complete.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const betaMessageBatch =
+     *   await client.beta.messages.batches.create({
+     *     requests: [
+     *       {
+     *         custom_id: 'my-custom-id-1',
+     *         params: {
+     *           max_tokens: 1024,
+     *           messages: [
+     *             { content: 'Hello, world', role: 'user' },
+     *           ],
+     *           model: 'claude-sonnet-4-20250514',
+     *         },
+     *       },
+     *     ],
+     *   });
+     * ```
+     */
+    create(params, options) {
+        const { betas, ...body } = params;
+        return this._client.post('/v1/messages/batches?beta=true', {
+            body,
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * This endpoint is idempotent and can be used to poll for Message Batch
+     * completion. To access the results of a Message Batch, make a request to the
+     * `results_url` field in the response.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const betaMessageBatch =
+     *   await client.beta.messages.batches.retrieve(
+     *     'message_batch_id',
+     *   );
+     * ```
+     */
+    retrieve(messageBatchID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get(path `/v1/messages/batches/${messageBatchID}?beta=true`, {
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * List all Message Batches within a Workspace. Most recently created batches are
+     * returned first.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const betaMessageBatch of client.beta.messages.batches.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(params = {}, options) {
+        const { betas, ...query } = params ?? {};
+        return this._client.getAPIList('/v1/messages/batches?beta=true', (Page), {
+            query,
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Delete a Message Batch.
+     *
+     * Message Batches can only be deleted once they've finished processing. If you'd
+     * like to delete an in-progress batch, you must first cancel it.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const betaDeletedMessageBatch =
+     *   await client.beta.messages.batches.delete(
+     *     'message_batch_id',
+     *   );
+     * ```
+     */
+    delete(messageBatchID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.delete(path `/v1/messages/batches/${messageBatchID}?beta=true`, {
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Batches may be canceled any time before processing ends. Once cancellation is
+     * initiated, the batch enters a `canceling` state, at which time the system may
+     * complete any in-progress, non-interruptible requests before finalizing
+     * cancellation.
+     *
+     * The number of canceled requests is specified in `request_counts`. To determine
+     * which requests were canceled, check the individual results within the batch.
+     * Note that cancellation may not result in any canceled requests if they were
+     * non-interruptible.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const betaMessageBatch =
+     *   await client.beta.messages.batches.cancel(
+     *     'message_batch_id',
+     *   );
+     * ```
+     */
+    cancel(messageBatchID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.post(path `/v1/messages/batches/${messageBatchID}/cancel?beta=true`, {
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * Streams the results of a Message Batch as a `.jsonl` file.
+     *
+     * Each line in the file is a JSON object containing the result of a single request
+     * in the Message Batch. Results are not guaranteed to be in the same order as
+     * requests. Use the `custom_id` field to match results to requests.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const betaMessageBatchIndividualResponse =
+     *   await client.beta.messages.batches.results(
+     *     'message_batch_id',
+     *   );
+     * ```
+     */
+    async results(messageBatchID, params = {}, options) {
+        const batch = await this.retrieve(messageBatchID);
+        if (!batch.results_url) {
+            throw new AnthropicError(`No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`);
+        }
+        const { betas } = params ?? {};
+        return this._client
+            .get(batch.results_url, {
+            ...options,
+            headers: buildHeaders([
+                {
+                    'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
+                    Accept: 'application/binary',
+                },
+                options?.headers,
+            ]),
+            stream: true,
+            __binaryResponse: true,
+        })
+            ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller));
+    }
+}
+
+export { Batches };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/beta/messages/messages.js

@@ -0,0 +1,85 @@
+import { APIResource } from '../../../core/resource.js';
+import { Batches } from './batches.js';
+import { buildHeaders } from '../../../internal/headers.js';
+import { BetaMessageStream } from '../../../lib/BetaMessageStream.js';
+import { MODEL_NONSTREAMING_TOKENS } from '../../../internal/constants.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+const DEPRECATED_MODELS = {
+    'claude-1.3': 'November 6th, 2024',
+    'claude-1.3-100k': 'November 6th, 2024',
+    'claude-instant-1.1': 'November 6th, 2024',
+    'claude-instant-1.1-100k': 'November 6th, 2024',
+    'claude-instant-1.2': 'November 6th, 2024',
+    'claude-3-sonnet-20240229': 'July 21st, 2025',
+    'claude-3-opus-20240229': 'January 5th, 2026',
+    'claude-2.1': 'July 21st, 2025',
+    'claude-2.0': 'July 21st, 2025',
+    'claude-3-5-sonnet-20241022': 'October 22, 2025',
+    'claude-3-5-sonnet-20240620': 'October 22, 2025',
+};
+class Messages extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.batches = new Batches(this._client);
+    }
+    create(params, options) {
+        const { betas, ...body } = params;
+        if (body.model in DEPRECATED_MODELS) {
+            console.warn(`The model '${body.model}' is deprecated and will reach end-of-life on ${DEPRECATED_MODELS[body.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);
+        }
+        let timeout = this._client._options.timeout;
+        if (!body.stream && timeout == null) {
+            const maxNonstreamingTokens = MODEL_NONSTREAMING_TOKENS[body.model] ?? undefined;
+            timeout = this._client.calculateNonstreamingTimeout(body.max_tokens, maxNonstreamingTokens);
+        }
+        return this._client.post('/v1/messages?beta=true', {
+            body,
+            timeout: timeout ?? 600000,
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+            stream: params.stream ?? false,
+        });
+    }
+    /**
+     * Create a Message stream
+     */
+    stream(body, options) {
+        return BetaMessageStream.createMessage(this, body, options);
+    }
+    /**
+     * Count the number of tokens in a Message.
+     *
+     * The Token Count API can be used to count the number of tokens in a Message,
+     * including tools, images, and documents, without creating it.
+     *
+     * Learn more about token counting in our
+     * [user guide](/en/docs/build-with-claude/token-counting)
+     *
+     * @example
+     * ```ts
+     * const betaMessageTokensCount =
+     *   await client.beta.messages.countTokens({
+     *     messages: [{ content: 'string', role: 'user' }],
+     *     model: 'claude-3-7-sonnet-latest',
+     *   });
+     * ```
+     */
+    countTokens(params, options) {
+        const { betas, ...body } = params;
+        return this._client.post('/v1/messages/count_tokens?beta=true', {
+            body,
+            ...options,
+            headers: buildHeaders([
+                { 'anthropic-beta': [...(betas ?? []), 'token-counting-2024-11-01'].toString() },
+                options?.headers,
+            ]),
+        });
+    }
+}
+Messages.Batches = Batches;
+
+export { Messages };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/beta/models.js

@@ -0,0 +1,58 @@
+import { APIResource } from '../../core/resource.js';
+import { Page } from '../../core/pagination.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { path } from '../../internal/utils/path.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Models extends APIResource {
+    /**
+     * Get a specific model.
+     *
+     * The Models API response can be used to determine information about a specific
+     * model or resolve a model alias to a model ID.
+     *
+     * @example
+     * ```ts
+     * const betaModelInfo = await client.beta.models.retrieve(
+     *   'model_id',
+     * );
+     * ```
+     */
+    retrieve(modelID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get(path `/v1/models/${modelID}?beta=true`, {
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * List available models.
+     *
+     * The Models API response can be used to determine which models are available for
+     * use in the API. More recently released models are listed first.
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const betaModelInfo of client.beta.models.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(params = {}, options) {
+        const { betas, ...query } = params ?? {};
+        return this._client.getAPIList('/v1/models?beta=true', (Page), {
+            query,
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+}
+
+export { Models };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/completions.js

@@ -0,0 +1,21 @@
+import { APIResource } from '../core/resource.js';
+import { buildHeaders } from '../internal/headers.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Completions extends APIResource {
+    create(params, options) {
+        const { betas, ...body } = params;
+        return this._client.post('/v1/complete', {
+            body,
+            timeout: this._client._options.timeout ?? 600000,
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+            stream: params.stream ?? false,
+        });
+    }
+}
+
+export { Completions };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/messages/batches.js

@@ -0,0 +1,151 @@
+import { APIResource } from '../../core/resource.js';
+import { Page } from '../../core/pagination.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { JSONLDecoder } from '../../internal/decoders/jsonl.js';
+import { AnthropicError } from '../../core/error.js';
+import { path } from '../../internal/utils/path.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Batches extends APIResource {
+    /**
+     * Send a batch of Message creation requests.
+     *
+     * The Message Batches API can be used to process multiple Messages API requests at
+     * once. Once a Message Batch is created, it begins processing immediately. Batches
+     * can take up to 24 hours to complete.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const messageBatch = await client.messages.batches.create({
+     *   requests: [
+     *     {
+     *       custom_id: 'my-custom-id-1',
+     *       params: {
+     *         max_tokens: 1024,
+     *         messages: [
+     *           { content: 'Hello, world', role: 'user' },
+     *         ],
+     *         model: 'claude-sonnet-4-20250514',
+     *       },
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    create(body, options) {
+        return this._client.post('/v1/messages/batches', { body, ...options });
+    }
+    /**
+     * This endpoint is idempotent and can be used to poll for Message Batch
+     * completion. To access the results of a Message Batch, make a request to the
+     * `results_url` field in the response.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const messageBatch = await client.messages.batches.retrieve(
+     *   'message_batch_id',
+     * );
+     * ```
+     */
+    retrieve(messageBatchID, options) {
+        return this._client.get(path `/v1/messages/batches/${messageBatchID}`, options);
+    }
+    /**
+     * List all Message Batches within a Workspace. Most recently created batches are
+     * returned first.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const messageBatch of client.messages.batches.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(query = {}, options) {
+        return this._client.getAPIList('/v1/messages/batches', (Page), { query, ...options });
+    }
+    /**
+     * Delete a Message Batch.
+     *
+     * Message Batches can only be deleted once they've finished processing. If you'd
+     * like to delete an in-progress batch, you must first cancel it.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const deletedMessageBatch =
+     *   await client.messages.batches.delete('message_batch_id');
+     * ```
+     */
+    delete(messageBatchID, options) {
+        return this._client.delete(path `/v1/messages/batches/${messageBatchID}`, options);
+    }
+    /**
+     * Batches may be canceled any time before processing ends. Once cancellation is
+     * initiated, the batch enters a `canceling` state, at which time the system may
+     * complete any in-progress, non-interruptible requests before finalizing
+     * cancellation.
+     *
+     * The number of canceled requests is specified in `request_counts`. To determine
+     * which requests were canceled, check the individual results within the batch.
+     * Note that cancellation may not result in any canceled requests if they were
+     * non-interruptible.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const messageBatch = await client.messages.batches.cancel(
+     *   'message_batch_id',
+     * );
+     * ```
+     */
+    cancel(messageBatchID, options) {
+        return this._client.post(path `/v1/messages/batches/${messageBatchID}/cancel`, options);
+    }
+    /**
+     * Streams the results of a Message Batch as a `.jsonl` file.
+     *
+     * Each line in the file is a JSON object containing the result of a single request
+     * in the Message Batch. Results are not guaranteed to be in the same order as
+     * requests. Use the `custom_id` field to match results to requests.
+     *
+     * Learn more about the Message Batches API in our
+     * [user guide](/en/docs/build-with-claude/batch-processing)
+     *
+     * @example
+     * ```ts
+     * const messageBatchIndividualResponse =
+     *   await client.messages.batches.results('message_batch_id');
+     * ```
+     */
+    async results(messageBatchID, options) {
+        const batch = await this.retrieve(messageBatchID);
+        if (!batch.results_url) {
+            throw new AnthropicError(`No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`);
+        }
+        return this._client
+            .get(batch.results_url, {
+            ...options,
+            headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
+            stream: true,
+            __binaryResponse: true,
+        })
+            ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller));
+    }
+}
+
+export { Batches };