@squidcloud/client 1.0.495 → 1.0.496

package/dist/internal-common/src/public-types/ai-agent.public-types.d.ts

@@ -950,6 +950,12 @@ export interface AiStatusMessage {
     /** Optional tags providing additional metadata about the status. */
     tags?: Record<string, any>;
 }
+/**
+ * `errorType` on a failed chat/ask job when the AI provider itself failed (a stall, timeout, or
+ * unrecognized 5xx) rather than Squid or the caller's request.
+ * @category AI
+ */
+export declare const AI_PROVIDER_ERROR_TYPE = "AI_PROVIDER_ERROR";
 /** List of all chat history (memory) sources. */
 export declare const AI_CHAT_MESSAGE_SOURCE: readonly ["user", "ai"];
 /** Source of the chat history entry: either an AI response or a user. */
@@ -1068,17 +1074,12 @@ export interface UpsertContextStatusSuccess extends BaseUpsertContextStatus {
     imageFailureCount?: number;
 }
 /**
- * Machine-readable code identifying a specific upsert failure reason.
- *
- * `DUPLICATE_CONTENT` means the request omitted a contextId and its content is
- * byte-identical to an existing context in the same knowledge base.
- *
- * `EMBEDDING_FAILED` means extraction succeeded but embedding the context's chunks did not; the
- * content was not written (an overwrite target keeps its previous content) and the request can be
- * safely retried as-is.
+ * Names an upsert failure; `DUPLICATE_CONTENT` identifies existing content when contextId is omitted.
+ * `EMBEDDING_FAILED`, `EXTRACTION_TIMED_OUT`, `PROVIDER_ACCESS_DENIED`, and `SOURCE_UNREACHABLE` may
+ * succeed on retry. Document faults carry `retryable: false` because the same bytes fail again.
  * @category AI
  */
-export type UpsertContextErrorCode = 'DUPLICATE_CONTENT' | 'EMBEDDING_FAILED';
+export type UpsertContextErrorCode = 'CONTENT_TOO_LARGE' | 'DUPLICATE_CONTENT' | 'EMBEDDING_FAILED' | 'ENCRYPTED_DOCUMENT' | 'EXTRACTION_TIMED_OUT' | 'NO_EMBEDDABLE_CONTENT' | 'PROVIDER_ACCESS_DENIED' | 'SOURCE_OVER_PROVIDER_LIMIT' | 'SOURCE_UNREACHABLE' | 'UNREADABLE_WORKBOOK' | 'UNSUPPORTED_FILE_TYPE';
 /**
  * The existing context a `DUPLICATE_CONTENT` rejection points at — where the byte-identical original
  * already lives.
@@ -1105,6 +1106,11 @@ export interface UpsertContextStatusError extends BaseUpsertContextStatus {
     errorMessage: string;
     /** Machine-readable code for the failure, when one applies. */
     errorCode?: UpsertContextErrorCode;
+    /**
+     * Present only when the same bytes fail the same way again, so a caller must not retry the request
+     * as-is. Absence means the failure may be transient.
+     */
+    retryable?: false;
     /**
      * The existing context this request duplicated, when `errorCode` is `DUPLICATE_CONTENT`. Lets a caller
      * point the user at where the original already lives (e.g. its folder) instead of only reporting the

package/dist/internal-common/src/public-types/ai-knowledge-base.public-types.d.ts

@@ -1,4 +1,4 @@
-import { AgentContextRequest, AiChatModelSelection, AiReasoningEffort, ContextImageFailure, UpsertContextStatusError } from './ai-agent.public-types';
+import { AiChatModelSelection, AiReasoningEffort, ContextImageFailure, UpsertContextStatusError } from './ai-agent.public-types';
 import { AiEmbeddingsModelSelection, AiRerankProvider } from './ai-common.public-types';
 import { AiContextId, AiKnowledgeBaseId, AppId } from './communication.public-types';
 import { DocumentExtractionMethod } from './extraction.public-types';
@@ -265,6 +265,13 @@ export interface AiKnowledgeBaseGraphConceptsConfig {
  * @category AI
  */
 export declare const FOLDER_PATH_METADATA_FIELD_NAME = "folderPath";
+/**
+ * The canonical file-name metadata field: the source file's name, stamped by file ingestion (console
+ * upload, document connectors). Metadata extraction reads it, beside {@link FOLDER_PATH_METADATA_FIELD_NAME},
+ * as evidence about the document.
+ * @category AI
+ */
+export declare const FILE_NAME_METADATA_FIELD_NAME = "filename";
 /**
  * A path facet: a deterministic tree built by splitting a hierarchical path field on {@link separator}.
  * Interior nodes are the path prefixes; scoping a search to one node matches that folder and everything
@@ -498,9 +505,18 @@ export interface AiKnowledgeBaseContext {
      * content-level dedup on upsert. Absent on legacy contexts ingested before hashing was introduced.
      */
     contentHash?: string;
-    /** Original request configuration for how the context content was processed. */
-    requestConfig?: AgentContextRequest;
+    /**
+     * The options the context was ingested with, replayed when it is reupserted. Absent on contexts that
+     * carry none; their reupsert takes the defaults.
+     */
+    requestConfig?: AiKnowledgeBaseContextRequestConfig;
 }
+/**
+ * The ingestion request's options only. Everything else a reupsert needs lives on the context itself —
+ * its text or stored file, title, metadata and access scopes — where it can change after ingestion.
+ * @category AI
+ */
+export type AiKnowledgeBaseContextRequestConfig = Omit<AiKnowledgeBaseTextContextRequest, 'text' | 'title' | 'metadata' | 'scopes'> | Omit<AiKnowledgeBaseFileContextRequest, 'metadata' | 'scopes'>;
 /**
  * @category AI
  */
@@ -633,11 +649,10 @@ export interface AiKnowledgeBaseFileContextRequest extends BaseAiKnowledgeBaseCo
     /** The preferred method for extracting data from the document. */
     preferredExtractionMethod?: DocumentExtractionMethod;
     /**
-     * Whether Squid keeps or discards the original file.
-     *
-     * Keeping the original file allows reprocessing and the ability for the user to download it later.
-     *
-     * Defaults to false.
+     * Whether Squid discards the downloadable original once the file is extracted; the extracted text and
+     * images are stored either way. Defaults to false: the original is kept so the user can download it and
+     * Squid can reprocess it. Without it, `querySpreadsheetsWithAi` cannot open a workbook context and a
+     * reupsert of the context fails, on the sync and the bulk lane alike.
      */
     discardOriginalFile?: boolean;
 }
@@ -945,9 +960,9 @@ export interface GrepKnowledgeBaseResponse {
      */
     unscannedContextCount?: number;
     /**
-     * With `limitation: 'truncatedContent'`, the file names of documents known to have lost content at
-     * ingest. A bounded sample, not a complete list — present it as an example, and do not infer that
-     * documents missing from it are intact.
+     * Every in-scope document known to have lost content at ingest, by file name. Present whenever such a
+     * document is in scope, alongside whichever {@link limitation} the scan reported — a cut document is no
+     * less cut because the scan also stopped early. Absent when none is.
      */
     truncatedContentFileNames?: Array<string>;
 }
@@ -1710,7 +1725,8 @@ export interface QueryKnowledgeBaseGraphResponse {
     summaries?: Array<KnowledgeBaseGraphQueryGlobalSummary>;
 }
 /**
- * One context to stage through bulk ingestion.
+ * One context to stage through bulk ingestion. Unlike the sync request, `imageExtractionModel` is not
+ * accepted: a job bills one fixed vision model for every image it describes.
  * @category AI
  */
 export interface BulkIngestionContext {
@@ -1744,6 +1760,24 @@ export interface BulkIngestionContext {
      * same name, so a caller's choice survives whichever lane a deployment routes the upload through.
      */
     preferredExtractionMethod?: DocumentExtractionMethod;
+    /**
+     * The RAG type and chunk overlap this context is chunked and indexed with; mirrors the sync request's
+     * `options`, with the same defaults (the knowledge base's `ragType`, and the overlap that type implies).
+     * `chunkOverlap` must be a number below the 4,000-character chunk size.
+     */
+    options?: BaseAiKnowledgeBaseContextOptions;
+    /**
+     * Minimum width/height in pixels for an extracted image to be kept; mirrors the sync request's field of
+     * the same name. Smaller images are skipped, and an inline markdown/HTML image below it keeps its raw
+     * reference in the text.
+     */
+    imageMinSizePixels?: number;
+    /**
+     * Whether Squid discards a file context's downloadable original once it is extracted (the extracted
+     * text and images are stored either way); mirrors {@link AiKnowledgeBaseFileContextRequest.discardOriginalFile},
+     * with the same consequences. Ignored for a text context.
+     */
+    discardOriginalFile?: boolean;
     /**
      * Optional metadata associated with the context item; mirrors {@link BaseAiKnowledgeBaseContextRequest.metadata}.
      * Squid-reserved keys are stripped server-side, and values are validated/normalized against the target
@@ -1868,7 +1902,8 @@ export interface BulkIngestionFileStatus {
      * Machine-readable class of a failed file, for outcomes to treat differently from real failures.
      * Terminal — reported with `retryable: false` — are `'CONTENT_TOO_LARGE'` (past the per-context
      * ceiling), `'ENCRYPTED_DOCUMENT'`, `'NO_EMBEDDABLE_CONTENT'`, `'SOURCE_OVER_PROVIDER_LIMIT'` (the
-     * bytes exceed what the extraction provider accepts) and `'UNSUPPORTED_FILE_TYPE'`.
+     * bytes exceed what the extraction provider accepts), `'UNREADABLE_WORKBOOK'` (a spreadsheet whose
+     * content the parser cannot read) and `'UNSUPPORTED_FILE_TYPE'`.
      * `'DUPLICATE_CONTENT'` is a skip rather than a failure: the KB already holds this content.
      * `'EXTRACTION_TIMED_OUT'` stays retryable — the deadline is contended, so a borderline document can
      * cross it under load. So do `'SOURCE_UNREACHABLE'` (the provider could not fetch the source, which a
@@ -1877,7 +1912,7 @@ export interface BulkIngestionFileStatus {
      * file, so re-submit it in a fresh job; a file that alone exceeds the ceiling fails this way in every job.
      * Additive; absent for ordinary failures.
      */
-    errorCode?: 'CONTENT_TOO_LARGE' | 'DUPLICATE_CONTENT' | 'ENCRYPTED_DOCUMENT' | 'EXTRACTION_TIMED_OUT' | 'JOB_FULL' | 'NO_EMBEDDABLE_CONTENT' | 'PROVIDER_ACCESS_DENIED' | 'SOURCE_OVER_PROVIDER_LIMIT' | 'SOURCE_UNREACHABLE' | 'UNSUPPORTED_FILE_TYPE';
+    errorCode?: 'CONTENT_TOO_LARGE' | 'DUPLICATE_CONTENT' | 'ENCRYPTED_DOCUMENT' | 'EXTRACTION_TIMED_OUT' | 'JOB_FULL' | 'NO_EMBEDDABLE_CONTENT' | 'PROVIDER_ACCESS_DENIED' | 'SOURCE_OVER_PROVIDER_LIMIT' | 'SOURCE_UNREACHABLE' | 'UNREADABLE_WORKBOOK' | 'UNSUPPORTED_FILE_TYPE';
     /**
      * Present only on a failed file an extraction provider answered: a stable fingerprint of that answer
      * (provider, HTTP status and provider code), so a caller can tell the same failure repeating from a new one.
@@ -1895,7 +1930,25 @@ export interface BulkIngestionFileStatus {
     imageFailures?: Array<ContextImageFailure>;
     /** Total number of failed images, which exceeds `imageFailures.length` when the list was capped. */
     imageFailureCount?: number;
+    /**
+     * Set on a `completed` file that is stored and searchable but that the job withheld from graph indexing;
+     * the bulk counterpart of {@link UpsertKnowledgeBaseContextsResponse.graphIndexingSkippedContextIds}, and
+     * `graphIndexingSkipReason` says why. Records the job's own outcome: it is written when the job's graph
+     * run admits its files, which can be after the job completes (a poll of the job status sees it, the
+     * terminal push may not), and it stays set even if a later graph build indexes the file.
+     */
+    graphIndexingSkipped?: boolean;
+    /** Why graph indexing was withheld; present exactly when `graphIndexingSkipped` is. */
+    graphIndexingSkipReason?: BulkIngestionGraphSkipReason;
 }
+/**
+ * Why a bulk-ingested file was withheld from graph indexing. `'cap'`: the knowledge base is over its
+ * per-KB graph chunk cap (or the cap could not be checked and the job failed closed), so the file stays
+ * out until the cap allows it. `'queue'`: the graph-indexing queue was full when the file finalized; the
+ * file is left to the graph auto-build sweep, which indexes it under the same cap once the job goes quiet.
+ * @category AI
+ */
+export type BulkIngestionGraphSkipReason = 'cap' | 'queue';
 /**
  * Why a whole bulk-ingestion staging call was refused, on the `details` of its 400 response. The
  * refusal names the one context that caused it, so a caller recording per-file outcomes charges only

package/dist/internal-common/src/public-types/ai-voice.public-types.d.ts

@@ -78,6 +78,10 @@ export interface AnswerOpenAiVoiceCallRequest {
     model?: string;
     /** Voice of the realtime model; defaults to the integration's default voice. */
     voice?: string;
+    /** Whether caller speech interrupts the realtime model. Omitted values keep OpenAI's default. */
+    allowInterruptions?: boolean;
+    /** How readily OpenAI detects caller speech. Omitted values keep OpenAI's default. */
+    interruptionSensitivity?: 'low' | 'normal' | 'high';
     /** Instructions of the realtime model. */
     instructions: string;
     /** Spoken as soon as the call is answered; without it the model waits for the caller to speak first. */
@@ -124,6 +128,10 @@ export interface StartOpenAiWebVoiceCallRequest {
     model?: string;
     /** Voice of the realtime model. */
     voice?: string;
+    /** Whether caller speech interrupts the model; defaults to the phone line, then OpenAI's default. */
+    allowInterruptions?: boolean;
+    /** How readily caller speech is detected; defaults to the phone line, then OpenAI's default. */
+    interruptionSensitivity?: 'low' | 'normal' | 'high';
     /** Language the call starts in, as an ISO code or BCP-47 tag. */
     language?: string;
     /** Whether the caller may switch language mid-call. */

package/dist/internal-common/src/public-types/integration.public-types.d.ts

@@ -14,7 +14,7 @@ export declare const AUTH_INTEGRATION_TYPES: readonly ["auth0", "jwt_rsa", "jwt_
  * `AiAgentMcpServerConfig.oauthIntegrationId`). Kept in sync with the providers supported by the
  * MCP OAuth validation in core.
  */
-export declare const MCP_OAUTH_INTEGRATION_TYPES: readonly ["auth0"];
+export declare const MCP_OAUTH_INTEGRATION_TYPES: readonly ["auth0", "azure-entra-id", "azure-entra-external-id"];
 /** Supported integration types for GraphQL-based services. */
 export declare const GRAPHQL_INTEGRATION_TYPES: readonly ["graphql"];
 /** Supported integration types for HTTP-based services. */

package/dist/internal-common/src/public-types/job.public-types.d.ts

@@ -84,4 +84,18 @@ export interface AsyncJob<T = any> {
      * This is optional.
      */
     error?: string;
+    /**
+     * A machine-readable category for the error, if the job has failed. Lets a caller branch on the
+     * failure kind (e.g. `'AI_PROVIDER_ERROR'`) without parsing {@link error}.
+     */
+    errorType?: string;
+}
+/**
+ * An `Error` carrying a machine-readable {@link errorType}, thrown by `JobClient.awaitJob` when a
+ * failed job's {@link AsyncJob.errorType} is set. Lets a caller branch on the failure kind (e.g.
+ * `'AI_PROVIDER_ERROR'`) without parsing `message`.
+ */
+export interface JobError extends Error {
+    /** The category the failed job's error was tagged with, if any (e.g. `'AI_PROVIDER_ERROR'`). */
+    errorType?: string;
 }

package/dist/internal-common/src/types/ai-knowledge-base.types.d.ts

@@ -205,6 +205,18 @@ export interface AiKnowledgeBaseContextSizeRequest {
     /** The ID of the AIKnowledgeBase */
     knowledgeBaseId: AiKnowledgeBaseId;
 }
+/**
+ * Request structure for the internal test-only route that arms an app's next bulk-ingestion fulltext blob
+ * operations to fail, so the staging and finalize fallbacks can be exercised without a storage outage.
+ */
+export interface AiKnowledgeBaseFailNextBulkFulltextBlobOpsRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** How many blob uploads land before the next one fails; omitted leaves uploads alone. */
+    uploadsBeforeFailure?: number;
+    /** How many blob reads land before the next one fails; omitted leaves reads alone. */
+    readsBeforeFailure?: number;
+}
 /**
  * Request structure for the internal test-only route that arms the next `count` grep scans of a
  * knowledge base to fail at their `maxTimeMS` deadline.
@@ -216,7 +228,52 @@ export interface AiKnowledgeBaseFailNextGrepScansRequest {
     knowledgeBaseId: AiKnowledgeBaseId;
     /** How many upcoming scans fail; a non-positive value disarms. */
     count: number;
+    /** Whether the next truncated-file-name lookup fails; false disarms, absent leaves it alone. */
+    failNextTruncatedNameLookup?: boolean;
 }
+/**
+ * Where an armed bulk finalize failure throws: past the destructive-write boundary but before the vector
+ * write (nothing written), or right after it (the vectors are replaced, the record is not).
+ */
+export type BulkFinalizeFailurePhase = 'beforeVectorWrite' | 'afterVectorWrite';
+/**
+ * Request structure for the internal test-only route that arms the next `count` bulk-ingestion finalizes
+ * of a knowledge base to throw at `phase`.
+ */
+export interface AiKnowledgeBaseFailNextBulkFinalizeWritesRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /** How many upcoming finalizes fail; a non-positive value disarms. */
+    count: number;
+    /** Where in the finalize the armed failures throw. */
+    phase: BulkFinalizeFailurePhase;
+}
+/**
+ * Request structure for the internal test-only route that arms the next `count` finalize-time
+ * image-description reads of a bulk-ingested knowledge base to fail.
+ */
+export interface AiKnowledgeBaseFailNextImageDescriptionReadsRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /** How many upcoming reads fail; zero disarms. */
+    count: number;
+}
+/**
+ * Request structure for the internal test-only route that answers every image with a description derived
+ * from its own bytes and no vision call, so the sync and bulk lanes describe a file identically.
+ */
+export interface AiKnowledgeBaseStubImageDescriptionsRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** Arms the stub when true, disarms it when false. */
+    enabled: boolean;
+}
+/** Leading text of a stubbed image description; the rest is the sha256 of the image bytes. */
+export declare const STUB_IMAGE_DESCRIPTION_PREFIX = "Stubbed image description sha256:";
 /**
  * Request structure for the internal test-only route that makes one knowledge base's graph be built by
  * the deterministic stub extractor instead of by the model.
@@ -457,6 +514,53 @@ export interface AiKnowledgeBaseBackfillFulltextStatus {
     storedPartCount?: number;
     errorMessage?: string;
 }
+/** Longest context batch one `repairBulkFulltext` call accepts; larger work-lists are split by the caller. */
+export declare const REPAIR_BULK_FULLTEXT_MAX_CONTEXTS_PER_CALL = 20;
+/**
+ * Request structure for rebuilding the stored raw text (`kb_fulltext`) of bulk-ingested contexts from the
+ * bulk-ingestion rows their job retained: the staged pages plus the descriptions its `imageDescription`
+ * requests already produced. No vision call, so a repaired context reads exactly as a freshly ingested
+ * one at no model cost.
+ */
+export interface AiKnowledgeBaseRepairBulkFulltextRequest {
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /**
+     * The ids of the contexts to repair, at most {@link REPAIR_BULK_FULLTEXT_MAX_CONTEXTS_PER_CALL} per
+     * call. Each context's stored text is fully replaced, so re-running a context is safe.
+     */
+    contextIds: Array<AiContextId>;
+    /**
+     * Rebuilds a context whose staged pages are gone by re-extracting its stored source file, which runs
+     * the regular document lane and can bill OCR. Off by default; such contexts are skipped without it.
+     */
+    reextractMissingPages?: boolean;
+    /**
+     * The extraction method of the {@link reextractMissingPages} fallback, defaulting to the server's
+     * regular one. Name the method the original ingest used: a file extracted with OCR yields no text for
+     * its scanned pages under a method that does not run it, replacing the context's text with less of it.
+     */
+    extractionMethod?: DocumentExtractionMethod;
+}
+/** Response structure for a `repairBulkFulltext` call: one status per requested context, in request order. */
+export interface AiKnowledgeBaseRepairBulkFulltextResponse {
+    statuses: Array<AiKnowledgeBaseRepairBulkFulltextStatus>;
+}
+/** Outcome of repairing the raw text of one bulk-ingested context. */
+export interface AiKnowledgeBaseRepairBulkFulltextStatus {
+    contextId: AiContextId;
+    /**
+     * `repairedFromReextraction` rebuilt the pages from the stored source file because the row's own were
+     * gone: a fresh extraction, so its text is best-effort rather than the original's. `raced` means another
+     * ingest took the context over during the repair, so re-run it.
+     */
+    status: 'repaired' | 'repairedFromReextraction' | 'raced' | 'error' | 'skipped';
+    /** Why the context was left untouched, when it was skipped. `noJob` cannot be repaired by re-running. */
+    skippedReason?: 'notBulkIngested' | 'noJob' | 'jobActive' | 'noFileRow' | 'notFinalized' | 'pagesBounded' | 'noDescriptionRows' | 'noPages' | 'reingested';
+    /** How many parts (pages/sheets/image descriptions) were stored, on success. */
+    storedPartCount?: number;
+    errorMessage?: string;
+}
 /**
  * Response structure for getting size of context
  * @category AI

package/dist/internal-common/src/types/observability.types.d.ts

@@ -131,6 +131,8 @@ export interface AgentAuditLogUpdateEvent {
 }
 /** Tag for metric events. Value: '0' - not an error, '1' - is an error. */
 export declare const O11Y_TAG_IS_ERROR = "isError";
+/** Tag naming the organization an application belongs to. */
+export declare const O11Y_TAG_ORG_ID = "organizationId";
 /** Tag for log events. Metrics have an explicit appId field. */
 export declare const O11Y_TAG_APP_ID = "appId";
 /** Tag for metric and log events. */

package/dist/internal-common/src/utils/http.d.ts

@@ -1,24 +1,4 @@
 import { AppId } from '../public-types/communication.public-types';
 import { Stage } from '../types/stage';
-export declare const KOTLIN_CONTROLLERS: string[];
-/**
- * Returns true if the given path is served by Kotlin core in local dev (port 8001). All `/ws/*`
- * WebSocket paths are served by the TypeScript core (port 8000).
- */
-export declare function isKotlinPath(path: string): boolean;
 export declare function getEnvironmentPrefix(shard: string | undefined, region: string, cloudId: string, stage: Stage): string;
-export declare function getApplicationUrl(environmentPrefix: string, appId: string, path: string, appIdPlaceholder?: AppId, environmentPrefixPlaceholder?: string, forceKotlin?: boolean): string;
-/**
- * Returns the URL of [path] on the `core-query-kotlin` Service, addressed from inside the cluster.
- *
- * Naming the Service rather than building the public URL with {@link getApplicationUrl} keeps a
- * purely intra-cluster call off the external load balancer, which is what the Kotlin core's own
- * `getApplicationUrlInternal` already does for the hop in the other direction; and it makes the call
- * independent of where ingress sends [path], so moving that route cannot turn a forward into a
- * request back to this core.
- *
- * The Service is shared and not per-app, so the application is identified by the
- * `SquidHeaders.APP_ID` header rather than by the hostname. Local development has no cluster DNS and
- * keeps the per-app host on Kotlin's port.
- */
-export declare function getQueryKotlinServiceUrl(environmentPrefix: string, appId: AppId, path: string): string;
+export declare function getApplicationUrl(environmentPrefix: string, appId: string, path: string, appIdPlaceholder?: AppId, environmentPrefixPlaceholder?: string): string;

package/dist/internal-common/src/utils/serialization.d.ts

@@ -1,6 +1,12 @@
 export declare function sortKeys(json: unknown): any;
 export declare function normalizeJsonAsString(json: unknown): string;
 export declare function serializeObj(obj: unknown): string;
+/**
+ * A `JSON.stringify` replacer writing a `Date` as `{ $date }`, the form {@link deserializeObj} reads back,
+ * for callers that keep every other value's own `toJSON`. The date is read off the holder, since a
+ * replacer is handed the `toJSON` text of a date; an invalid date keeps that text, `null`.
+ */
+export declare function writeDateAsBson(this: Record<string, unknown>, key: string, value: unknown): unknown;
 export declare function deserializeObj<T = any>(str: string): T;
 /**
  * Deserializes a multipart request payload when present.

package/dist/typescript-client/src/job-client.d.ts

@@ -33,8 +33,9 @@ export declare class JobClient {
      */
     getJob<T = any>(jobId: JobId): Promise<AsyncJob<T> | undefined>;
     /**
-     * Waits until the specified job finishes, then resolves with its result or
-     * throws if the job fails.
+     * Waits until the specified job finishes, then resolves with its result or throws if the job
+     * fails. The thrown error is a {@link JobError}: check its `errorType` (e.g. `'AI_PROVIDER_ERROR'`)
+     * to branch on the failure kind without parsing `message`.
      *
      * @param jobId A unique, private identifier for the job.
      *              Do **not** reuse a `jobId` across clients—possessing the ID

package/dist/typescript-client/src/version.d.ts

@@ -2,4 +2,4 @@
  * The current version of the SquidCloud client package.
  * @category Platform
  */
-export declare const SQUIDCLOUD_CLIENT_PACKAGE_VERSION = "1.0.495";
+export declare const SQUIDCLOUD_CLIENT_PACKAGE_VERSION = "1.0.496";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.495",
+  "version": "1.0.496",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",