@tstdl/base 0.92.145 → 0.92.148

package/ai/ai.service.js

@@ -7,11 +7,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var _a;
 var AiService_1;
 import { FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
+import { CancellationSignal } from '../cancellation/index.js';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
 import { Logger } from '../logger/logger.js';
-import { getShutdownSignal } from '../process-shutdown.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { LazyPromise } from '../promise/lazy-promise.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
@@ -19,19 +19,28 @@ import { Schema } from '../schema/index.js';
 import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
+import { backoffGenerator } from '../utils/backoff.js';
 import { lazyObject } from '../utils/object/lazy-property.js';
 import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
-import { cancelableTimeout } from '../utils/timing.js';
 import { assertDefinedPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
-import { millisecondsPerSecond } from '../utils/units.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
 import { AiSession } from './ai-session.js';
 import { isSchemaFunctionDeclarationWithHandler } from './types.js';
+/**
+ * Options for configuring the {@link AiService}.
+ */
 export class AiServiceOptions {
+    /** Google AI API key. */
     apiKey;
+    /** Path to the Google Cloud credentials file. */
     keyFile;
+    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
     vertex;
+    /**
+     * The default model to use for generation requests.
+     * @default 'gemini-2.5-flash-lite'
+     */
     defaultModel;
 }
 ;
@@ -41,10 +50,17 @@ const functionCallingModeMap = {
     none: GoogleFunctionCallingMode.NONE,
 };
 let generationCounter = 0;
+/**
+ * A service for interacting with Google's Generative AI models (Gemini).
+ *
+ * This service provides methods for content generation, function calling, and file processing,
+ * supporting both standard Google AI and Vertex AI endpoints.
+ */
 let AiService = AiService_1 = class AiService {
     #options = injectArgument(this, { optional: true }) ?? inject(AiServiceOptions);
     #fileService = inject(AiFileService, this.#options);
     #logger = inject(Logger, AiService_1.name);
+    #cancellationSignal = inject(CancellationSignal);
     #genAI = new GoogleGenAI({
         vertexai: isDefined(this.#options.vertex?.project),
         project: this.#options.vertex?.project,
@@ -53,19 +69,56 @@ let AiService = AiService_1 = class AiService {
         apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
     });
     #maxOutputTokensCache = new Map();
-    defaultModel = this.#options.defaultModel ?? 'gemini-2.5-flash-lite-preview-06-17';
+    #backoffOptions = {
+        cancellationSignal: this.#cancellationSignal,
+        strategy: 'exponential',
+        initialDelay: 2500,
+        increase: 1.5,
+        jitter: 0.2,
+        maximumDelay: 30000,
+    };
+    /**
+     * The default AI model to use for requests if not specified otherwise.
+     */
+    defaultModel = this.#options.defaultModel ?? 'gemini-2.5-flash-lite';
+    /**
+     * Creates a new {@link AiSession} for managing conversational history.
+     */
     createSession() {
         return new AiSession(this);
     }
+    /**
+     * Processes a single file for use in AI requests by uploading it and making it available to the model.
+     * @param fileInput The file to process.
+     * @returns A promise that resolves to a {@link FileContentPart} which can be included in a generation request.
+     */
     async processFile(fileInput) {
         return await this.#fileService.processFile(fileInput);
     }
+    /**
+     * Processes multiple files in parallel for use in AI requests.
+     * @param fileInputs The files to process.
+     * @returns A promise that resolves to an array of {@link FileContentPart}s which can be included in generation requests.
+     */
     async processFiles(fileInputs) {
         return await this.#fileService.processFiles(fileInputs);
     }
+    /**
+     * Creates a file content part from a previously processed file ID.
+     * This does not re-upload the file.
+     * @param id The ID of the file, obtained from {@link AiFileService.processFile} or {@link AiFileService.processFiles}.
+     * @returns A {@link FileContentPart} for use in a generation request.
+     */
     getFileById(id) {
         return { file: id };
     }
+    /**
+     * A high-level method to prompt the model to call one or more functions.
+     * This method sends the request and parses the model's response to identify function calls.
+     * If the function declaration includes a handler, it will be executed automatically.
+     * @param options The options for the function call request.
+     * @returns A promise that resolves to a {@link SpecializedGenerationResult} containing the function call results.
+     */
     async callFunctions(options) {
         const generation = await this.generate({
             model: options.model,
@@ -94,9 +147,15 @@ let AiService = AiService_1 = class AiService {
         return {
             result,
             raw: generation,
-            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart()),
         };
     }
+    /**
+     * A streaming version of `callFunctions`.
+     * Yields function call results as they are received from the model.
+     * If function declarations include handlers, they are executed as soon as a complete function call is parsed.
+     * @param options The options for the function call request.
+     * @returns A {@link SpecializedGenerationResultGenerator} that yields function call results.
+     */
     callFunctionsStream(options) {
         const itemsPromise = new DeferredPromise();
         const generator = this._callFunctionsStream(options, itemsPromise);
@@ -106,10 +165,22 @@ let AiService = AiService_1 = class AiService {
         });
         return generator;
     }
+    /**
+     * Generates content from the model based on a request.
+     * This method waits for the full response from the model. For streaming, use {@link generateStream}.
+     * @param request The generation request.
+     * @returns A promise that resolves to the complete {@link GenerationResult}.
+     */
     async generate(request) {
         const items = await toArrayAsync(this.generateStream(request));
         return mergeGenerationStreamItems(items, request.generationSchema);
     }
+    /**
+     * Generates content as a stream.
+     * Yields partial generation results as they are received from the model.
+     * @param request The generation request.
+     * @returns An `AsyncGenerator` that yields {@link GenerationResult} chunks.
+     */
     async *generateStream(request) {
         const generationNumber = ++generationCounter;
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
@@ -141,7 +212,8 @@ let AiService = AiService_1 = class AiService {
         let totalTokens = 0;
         while (totalOutputTokens < maxTotalOutputTokens) {
             let generation;
-            for (let i = 0;; i++) {
+            let triesLeft = 10;
+            for await (const backoff of backoffGenerator(this.#backoffOptions)) {
                 try {
                     this.#logger.verbose(`[C:${generationNumber}] [I:${iterations + 1}] Generating...`);
                     generation = await this.#genAI.models.generateContentStream({
@@ -155,14 +227,13 @@ let AiService = AiService_1 = class AiService {
                     break;
                 }
                 catch (error) {
-                    if ((i < 20) && isError(error) && (error.message.includes('429 Too Many Requests') || (error.message.includes('503 Service Unavailable')))) {
-                        this.#logger.verbose('429 Too Many Requests - trying again in 15 seconds');
-                        const timeoutResult = await cancelableTimeout(15 * millisecondsPerSecond, getShutdownSignal());
-                        if (timeoutResult == 'timeout') {
-                            continue;
-                        }
+                    triesLeft -= 1;
+                    if ((triesLeft > 0) && isError(error) && (error.message.includes('429 Too Many Requests') || error.message.includes('503 Service Unavailable'))) {
+                        this.#logger.verbose(`Retrying after transient error: ${error.message}`);
+                        backoff();
+                        continue;
                     }
-                    throw error;
+                    throw error; // Non-retryable error
                 }
             }
             iterations++;
@@ -266,7 +337,23 @@ let AiService = AiService_1 = class AiService {
         return await promise;
     }
     async _getModelOutputTokenLimit(model) {
-        const modelInfo = await this.#genAI.models.get({ model });
+        let modelInfo;
+        let triesLeft = 10;
+        for await (const backoff of backoffGenerator(this.#backoffOptions)) {
+            try {
+                modelInfo = await this.#genAI.models.get({ model });
+                break;
+            }
+            catch (error) {
+                triesLeft -= 1;
+                if ((triesLeft > 0) && isError(error) && (error.message.includes('429 Too Many Requests') || error.message.includes('503 Service Unavailable'))) {
+                    this.#logger.verbose(`Could not get model info for ${model} due to a transient error (${error.message}). Retrying...`);
+                    backoff();
+                    continue;
+                }
+                throw error;
+            }
+        }
         if (isUndefined(modelInfo.outputTokenLimit)) {
             throw new Error(`Model ${model} does not support maxOutputTokens`);
         }
@@ -345,33 +432,49 @@ AiService = AiService_1 = __decorate([
     Singleton()
 ], AiService);
 export { AiService };
+/**
+ * Merges an array of streaming generation results into a single, consolidated result.
+ * This is useful for combining the chunks from a streaming response into a final object.
+ * @param items The array of {@link GenerationResult} items from a stream.
+ * @param schema An optional schema to parse the merged JSON output.
+ * @returns A single, merged {@link GenerationResult}.
+ */
 export function mergeGenerationStreamItems(items, schema) {
+    if (items.length == 0) {
+        return {
+            content: { role: 'model', parts: [] },
+            text: null,
+            json: undefined,
+            functionCalls: [],
+            finishReason: 'unknown',
+            usage: { iterations: 0, prompt: 0, output: 0, total: 0 },
+        };
+    }
     const parts = items.flatMap((item) => item.content.parts);
-    let text;
-    let functionCallParts;
     return lazyObject({
         content: { value: { role: 'model', parts } },
         text() {
-            if (isUndefined(text)) {
-                const textParts = parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
-                text = (textParts.length > 0) ? textParts.join('') : null;
-            }
-            return text;
+            const textParts = parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
+            return (textParts.length > 0) ? textParts.join('') : null;
         },
         json() {
             if (isUndefined(schema)) {
-                return undefined; // eslint-disable-line @typescript-eslint/no-unsafe-return
+                return undefined;
             }
             if (isNull(this.text)) {
                 throw new Error('No text to parse available.');
             }
-            return Schema.parse(schema, JSON.parse(this.text));
+            let parsed;
+            try {
+                parsed = JSON.parse(this.text);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse model output as JSON. Raw text: "${this.text}"`, { cause: error });
+            }
+            return Schema.parse(schema, parsed);
         },
         functionCalls() {
-            if (isUndefined(functionCallParts)) {
-                functionCallParts = parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
-            }
-            return functionCallParts;
+            return parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
         },
         finishReason: { value: items.at(-1).finishReason },
         usage: { value: items.at(-1).usage },

package/ai/functions.d.ts

@@ -1,3 +1,9 @@
 import type { FunctionDeclaration } from '@google/genai';
-import type { AbstractConstructor } from '../types.js';
+import type { AbstractConstructor } from '../types/index.js';
+/**
+ * Extracts Google AI function declarations from a class decorated with schema information.
+ * It iterates over the properties of the class schema and converts `FunctionSchema` instances
+ * into the format required by the Google Generative AI API.
+ * @param type The constructor of the class to extract function declarations from.
+ */
 export declare function getFunctionDeclarations(type: AbstractConstructor): FunctionDeclaration[];

package/ai/functions.js

@@ -2,6 +2,12 @@ import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.j
 import { FunctionSchema, getObjectSchema, object } from '../schema/index.js';
 import { fromEntries, objectEntries } from '../utils/object/object.js';
 import { isNotNull, isNull, isString } from '../utils/type-guards.js';
+/**
+ * Extracts Google AI function declarations from a class decorated with schema information.
+ * It iterates over the properties of the class schema and converts `FunctionSchema` instances
+ * into the format required by the Google Generative AI API.
+ * @param type The constructor of the class to extract function declarations from.
+ */
 export function getFunctionDeclarations(type) {
     const objectSchema = getObjectSchema(type);
     return objectEntries(objectSchema.properties)
@@ -14,7 +20,7 @@ export function getFunctionDeclarations(type) {
             description: schema.description ?? undefined,
             parameters: isNull(schema.parameterSchemas)
                 ? undefined
-                : getFunctionDeclarationParameters(schema)
+                : getFunctionDeclarationParameters(schema),
         };
     })
         .filter(isNotNull);

package/ai/module.d.ts

@@ -1,3 +1,11 @@
 import { AiServiceOptions } from './ai.service.js';
+/**
+ * Options for configuring the AI module.
+ * @see {@link AiServiceOptions}
+ */
 export type ApiModuleOptions = AiServiceOptions;
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
 export declare function configureAiService(options: ApiModuleOptions): void;

package/ai/module.js

@@ -1,5 +1,9 @@
 import { Injector } from '../injector/injector.js';
 import { AiServiceOptions } from './ai.service.js';
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
 export function configureAiService(options) {
     Injector.register(AiServiceOptions, { useValue: options });
 }

package/ai/types.d.ts

@@ -1,91 +1,204 @@
 import type { LiteralUnion } from 'type-fest';
 import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { Record, UndefinableJsonObject } from '../types.js';
+import type { Record, UndefinableJsonObject } from '../types/index.js';
 import type { ResolvedValueOrProvider, ValueOrAsyncProvider } from '../utils/value-or-provider.js';
+/**
+ * Represents a file to be uploaded, either from a local path or as a `Blob`.
+ */
 export type FileInput = {
     path: string;
     mimeType: string;
 } | Blob;
+/**
+ * A record of named function declarations, where each key is the function name.
+ */
 export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
+/**
+ * A function declaration that only defines the function's signature (name, description, parameters).
+ * @template T The record type for the function's parameters.
+ */
 export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
     description: string;
     parameters?: ValueOrAsyncProvider<ObjectSchema<T>>;
     enabled?: ValueOrAsyncProvider<boolean>;
 };
+/**
+ * A function declaration that includes a handler to be executed when the function is called by the model.
+ * @template T The record type for the function's parameters.
+ * @template R The return type of the handler.
+ */
 export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
     handler: (parameters: T) => R | Promise<R>;
 };
+/**
+ * A union of a function declaration with or without a handler.
+ * @template T The record type for the function's parameters.
+ * @template R The return type of the handler if it exists.
+ */
 export type SchemaFunctionDeclaration<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> | SchemaFunctionDeclarationWithHandler<T, R>;
+/**
+ * Extracts the return type of a function declaration's handler.
+ * If the declaration has no handler, it resolves to `never`.
+ * @template T The function declaration type.
+ */
 export type SchemaFunctionDeclarationHandlerResult<T extends SchemaFunctionDeclaration> = T extends SchemaFunctionDeclarationWithHandler<any, infer R> ? R : never;
+/**
+ * Represents the result of a function call, typed based on the provided declarations.
+ * This is a distributive conditional type that maps over the function declarations.
+ * @template T The schema declarations for the available functions.
+ */
 export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclarations = SchemaFunctionDeclarations> = {
     [P in keyof T]: {
+        /** The name of the function that was called. */
         functionName: P;
+        /** The parameters passed to the function call, parsed against the schema. */
         parameters: SchemaOutput<NonNullable<ResolvedValueOrProvider<T[P]['parameters']>>>;
+        /** The result of executing the handler, if one was provided. */
         handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
+        /** A function to get the content part representing the function result, for use in subsequent AI requests. */
         getFunctionResultContentPart: () => FunctionResultContentPart;
     };
 }[keyof T];
+/**
+ * The role of the author of a piece of content.
+ */
 export type ContentRole = 'user' | 'model';
+/** A part of a `Content` object containing text. */
 export type TextContentPart = {
     text: string;
 };
+/** A part of a `Content` object referencing a processed file via its ID. */
 export type FileContentPart = {
     file: string;
 };
+/** Represents a function call requested by the model. */
 export type FunctionCall = {
     name: string;
     parameters: UndefinableJsonObject;
 };
+/** A part of a `Content` object representing a function call request from the model. */
 export type FunctionCallContentPart = {
     functionCall: FunctionCall;
 };
+/** The result of a function execution. */
 export type FunctionResult = {
     name: string;
     value: UndefinableJsonObject;
 };
+/** A part of a `Content` object representing the result of a function call. */
 export type FunctionResultContentPart = {
     functionResult: FunctionResult;
 };
+/** A union of all possible content part types. */
 export type ContentPart = TextContentPart | FileContentPart | FunctionCallContentPart | FunctionResultContentPart;
+/** A single message in a conversation, containing a role and one or more parts. */
 export type Content = {
     role: ContentRole;
     parts: readonly ContentPart[];
 };
+/**
+ * Specifies the mode for function calling.
+ * - `auto`: The model decides whether to call a function.
+ * - `force`: The model is forced to call a function.
+ * - `none`: The model will not call any functions.
+ */
 export type FunctionCallingMode = 'auto' | 'force' | 'none';
+/**
+ * The reason why the model stopped generating content.
+ */
 export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
-export type AiModel = LiteralUnion<'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite-preview-06-17', string>;
+/**
+ * The specific AI model to use for a request.
+ */
+export type AiModel = LiteralUnion<'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite', string>;
+/**
+ * Options to control the generation process.
+ */
 export type GenerationOptions = {
+    /** The maximum number of tokens to generate in the response. */
     maxOutputTokens?: number;
+    /** Controls the randomness of the output. Higher values (closer to 1.0) make the output more random. */
     temperature?: number;
+    /** The cumulative probability of tokens to consider for sampling. */
     topP?: number;
+    /** The number of highest-probability tokens to consider for sampling. */
     topK?: number;
+    /** A penalty for tokens that have already appeared in the text. */
     presencePenalty?: number;
+    /** A penalty for tokens based on their frequency in the text. */
     frequencyPenalty?: number;
+    /**
+     * The maximum number of tokens the model is allowed to generate for its thinking phase.
+     */
     thinkingBudget?: number;
 };
+/**
+ * A request to generate content from the AI model.
+ * @template S The expected type of the `json` property in the result if `generationSchema` is provided.
+ */
 export type GenerationRequest<S = unknown> = {
+    /** The model to use for the request. If not provided, a default will be used. */
     model?: AiModel;
+    /** A system instruction to guide the model's behavior. */
     systemInstruction?: string;
+    /** The content or conversation history to send to the model. */
     contents: Content | readonly Content[];
+    /** A set of functions the model can call. */
     functions?: SchemaFunctionDeclarations;
+    /** The mode for function calling. */
     functionCallingMode?: FunctionCallingMode;
+    /** A schema to which the model's output should conform. Implies `responseMimeType: 'application/json'`. */
     generationSchema?: SchemaTestable<S>;
+    /** Options to control the generation process. */
     generationOptions?: GenerationOptions;
 };
+/**
+ * Token usage statistics for a generation request.
+ */
 export type GenerationUsage = {
+    /** The number of generation iterations (usually 1, more if `maxOutputTokens` is hit and generation continues). */
     iterations: number;
+    /** The number of tokens in the prompt. */
     prompt: number;
+    /** The number of tokens in the generated output. */
     output: number;
+    /** The total number of tokens used. */
     total: number;
 };
+/**
+ * The result of a generation request.
+ * @template S The expected type of the `json` property if a schema was provided in the request.
+ */
 export type GenerationResult<S = unknown> = {
+    /** The content generated by the model. */
     content: Content;
+    /** The complete text generated by the model, or `null` if no text was generated. */
     text: string | null;
+    /** The text parsed as JSON, conforming to the provided schema. `undefined` if no schema was provided. */
     json: S;
+    /** An array of function calls requested by the model. */
     functionCalls: FunctionCall[];
+    /** The reason why the model stopped generating. */
     finishReason: FinishReason;
+    /** Token usage statistics for the request. */
     usage: GenerationUsage;
 };
+/**
+ * A helper function to define a set of function declarations with strong type inference.
+ * @param declarations A record of function declarations.
+ * @returns The same record of declarations, with types preserved.
+ */
 export declare function defineFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
+/**
+ * A helper function to define a single function declaration with strong type inference,
+ * particularly for its parameters.
+ * @param declaration The function declaration.
+ * @returns The same declaration, with types preserved.
+ */
 export declare function defineFunction<P extends Record, T extends SchemaFunctionDeclaration<P>>(declaration: T & Pick<SchemaFunctionDeclaration<P>, 'parameters'>): T;
+/**
+ * A type guard to check if a function declaration includes a handler.
+ * @param declaration The function declaration to check.
+ * @returns `true` if the declaration has a `handler` property, `false` otherwise.
+ */
 export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;

package/ai/types.js

@@ -1,10 +1,26 @@
 import { hasOwnProperty } from '../utils/object/object.js';
+/**
+ * A helper function to define a set of function declarations with strong type inference.
+ * @param declarations A record of function declarations.
+ * @returns The same record of declarations, with types preserved.
+ */
 export function defineFunctions(declarations) {
     return declarations;
 }
+/**
+ * A helper function to define a single function declaration with strong type inference,
+ * particularly for its parameters.
+ * @param declaration The function declaration.
+ * @returns The same declaration, with types preserved.
+ */
 export function defineFunction(declaration) {
     return declaration;
 }
+/**
+ * A type guard to check if a function declaration includes a handler.
+ * @param declaration The function declaration to check.
+ * @returns `true` if the declaration has a `handler` property, `false` otherwise.
+ */
 export function isSchemaFunctionDeclarationWithHandler(declaration) {
     return hasOwnProperty(declaration, 'handler');
 }

package/api/client/client.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient, type HttpClientOptions } from '../../http/client/index.js';
+import { bustCacheToken } from '../../http/index.js';
 import { type Resolvable } from '../../injector/interfaces.js';
-import type { Type } from '../../types.js';
+import type { Type } from '../../types/index.js';
 import { type ApiClientImplementation, type ApiDefinition, type ApiEndpointDefinition } from '../types.js';
 export type ApiClient<T extends ApiDefinition> = Type<ApiClientImplementation<T> & Resolvable<HttpClient | HttpClientOptions>, [httpClientOrOptions?: HttpClient | HttpClientOptions]> & Pick<ApiClientImplementation<T>, 'getEndpointResource' | 'getEndpointUrl'>;
 export type ClientOptions = {
@@ -13,6 +14,7 @@ export type ClientOptions = {
 };
 export type ApiClientHttpRequestContext = {
     endpoint: ApiEndpointDefinition;
+    [bustCacheToken]?: boolean;
 };
 export declare const httpClientSymbol: unique symbol;
 export declare const apiDefinitionSymbol: unique symbol;

package/api/client/client.js

@@ -1,5 +1,5 @@
 import { HttpClient, HttpClientRequest } from '../../http/client/index.js';
-import { normalizeSingleHttpValue } from '../../http/types.js';
+import { bustCacheToken, normalizeSingleHttpValue } from '../../http/index.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
@@ -13,7 +13,7 @@ import { buildUrl } from '../../utils/url-builder.js';
 import { resolveValueOrProvider } from '../../utils/value-or-provider.js';
 import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
 import { getFullApiEndpointResource } from '../utils.js';
-export const httpClientSymbol = Symbol('ApiTransport');
+export const httpClientSymbol = Symbol('HttpClient for ApiClient');
 export const apiDefinitionSymbol = Symbol('ApiDefinition');
 export const defaultOptions = {};
 export function setDefaultApiClientOptions(options) {
@@ -74,6 +74,9 @@ export function compileClient(definition, options = defaultOptions) {
                     }
                     return getServerSentEvents(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters);
                 }
+                if (context.endpoint.data?.[bustCacheToken] == true) {
+                    context[bustCacheToken] = true;
+                }
                 const request = new HttpClientRequest({
                     method,
                     url: resource,

package/api/default-error-handlers.d.ts

@@ -1,5 +1,5 @@
 import { SchemaError } from '../schema/index.js';
-import type { OneOrMany } from '../types.js';
+import type { OneOrMany } from '../types/index.js';
 export type SerializedSchemaError = {
     path: string;
     details?: any;

package/api/index.d.ts

@@ -1,13 +1,5 @@
 /**
- * Create and consume HTTP APIs
- *
- * It has built-in support for validation and error handling.
- *
- * This module contains types and functions to define and register apis and error handlers.
- *
- * Consumers of these definitions are [client](api_client.html) and [server](api_server.html).
- *
- * Examples can be found in `source/examples/api/`.
+ * {@include ./README.md}
  *
  * @module API
  */

package/api/index.js

@@ -1,13 +1,5 @@
 /**
- * Create and consume HTTP APIs
- *
- * It has built-in support for validation and error handling.
- *
- * This module contains types and functions to define and register apis and error handlers.
- *
- * Consumers of these definitions are [client](api_client.html) and [server](api_server.html).
- *
- * Examples can be found in `source/examples/api/`.
+ * {@include ./README.md}
  *
  * @module API
  */

package/api/response.d.ts

@@ -1,5 +1,5 @@
 import { type CustomError, type CustomErrorStatic } from '../errors/index.js';
-import type { UndefinableJson } from '../types.js';
+import type { UndefinableJson } from '../types/index.js';
 export type ErrorHandlerData = undefined | UndefinableJson;
 export type ErrorSerializer<T extends CustomError, TData extends ErrorHandlerData> = (error: T) => TData;
 export type ErrorDeserializer<T extends CustomError, TData extends ErrorHandlerData> = (data: TData, responseError: ResponseError) => T;