@squidcloud/client 1.0.325 → 1.0.327

package/dist/internal-common/src/public-types/http-status.enum.d.ts

@@ -1,50 +1,414 @@
-export declare enum HttpStatus {
-    CONTINUE = 100,
-    SWITCHING_PROTOCOLS = 101,
-    PROCESSING = 102,
-    EARLYHINTS = 103,
-    OK = 200,
-    CREATED = 201,
-    ACCEPTED = 202,
-    NON_AUTHORITATIVE_INFORMATION = 203,
-    NO_CONTENT = 204,
-    RESET_CONTENT = 205,
-    PARTIAL_CONTENT = 206,
-    AMBIGUOUS = 300,
-    MOVED_PERMANENTLY = 301,
-    FOUND = 302,
-    SEE_OTHER = 303,
-    NOT_MODIFIED = 304,
-    TEMPORARY_REDIRECT = 307,
-    PERMANENT_REDIRECT = 308,
-    BAD_REQUEST = 400,
-    UNAUTHORIZED = 401,
-    PAYMENT_REQUIRED = 402,
-    FORBIDDEN = 403,
-    NOT_FOUND = 404,
-    METHOD_NOT_ALLOWED = 405,
-    NOT_ACCEPTABLE = 406,
-    PROXY_AUTHENTICATION_REQUIRED = 407,
-    REQUEST_TIMEOUT = 408,
-    CONFLICT = 409,
-    GONE = 410,
-    LENGTH_REQUIRED = 411,
-    PRECONDITION_FAILED = 412,
-    PAYLOAD_TOO_LARGE = 413,
-    URI_TOO_LONG = 414,
-    UNSUPPORTED_MEDIA_TYPE = 415,
-    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
-    EXPECTATION_FAILED = 417,
-    I_AM_A_TEAPOT = 418,
-    MISDIRECTED = 421,
-    UNPROCESSABLE_ENTITY = 422,
-    FAILED_DEPENDENCY = 424,
-    PRECONDITION_REQUIRED = 428,
-    TOO_MANY_REQUESTS = 429,
-    INTERNAL_SERVER_ERROR = 500,
-    NOT_IMPLEMENTED = 501,
-    BAD_GATEWAY = 502,
-    SERVICE_UNAVAILABLE = 503,
-    GATEWAY_TIMEOUT = 504,
-    HTTP_VERSION_NOT_SUPPORTED = 505
-}
+/** Set of constants for HTTP status codes. */
+export declare const HttpStatus: {
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.2.1
+     *
+     * This interim response indicates that everything so far is OK and that the client should continue with the request
+     * or ignore it if it is already finished.
+     */
+    readonly CONTINUE: 100;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.2.2
+     *
+     * This code is sent in response to an Upgrade request header by the client, and indicates the protocol the server is
+     * switching too.
+     */
+    readonly SWITCHING_PROTOCOLS: 101;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.1
+     *
+     * This code indicates that the server has received and is processing the request, but no response is available yet.
+     */
+    readonly PROCESSING: 102;
+    /**
+     * Official Documentation: https://www.rfc-editor.org/rfc/rfc8297#page-3
+     *
+     * This code indicates to the client that the server is likely to send a final response with the header fields
+     * included in the informational response.
+     */
+    readonly EARLY_HINTS: 103;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.1
+     *
+     * The request has succeeded. The meaning of a success varies depending on the HTTP method:
+     * GET: The resource has been fetched and is transmitted in the message body.
+     * HEAD: The entity headers are in the message body.
+     * POST: The resource describing the result of the action is transmitted in the message body.
+     * TRACE: The message body contains the request message as received by the server
+     */
+    readonly OK: 200;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.2
+     *
+     * The request has succeeded and a new resource has been created as a result of it. This is typically the response
+     * sent after a PUT request.
+     */
+    readonly CREATED: 201;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.3
+     *
+     * The request has been received but not yet acted upon. It is non-committal, meaning that there is no way in HTTP to
+     * later send an asynchronous response indicating the outcome of processing the request. It is intended for cases
+     * where another process or server handles the request, or for batch processing.
+     */
+    readonly ACCEPTED: 202;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.4
+     *
+     * This response code means returned meta-information set is not exact set as available from the origin server, but
+     * collected from a local or a third party copy. Except this condition, 200 OK response should be preferred instead
+     * of this response.
+     */
+    readonly NON_AUTHORITATIVE_INFORMATION: 203;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.5
+     *
+     * There is no content to send for this request, but the headers may be useful. The user-agent may update its cached
+     * headers for this resource with the new ones.
+     */
+    readonly NO_CONTENT: 204;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.3.6
+     *
+     * This response code is sent after accomplishing request to tell user agent reset document view which sent this
+     * request.
+     */
+    readonly RESET_CONTENT: 205;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7233#section-4.1
+     *
+     * This response code is used because of range header sent by the client to separate download into multiple streams.
+     */
+    readonly PARTIAL_CONTENT: 206;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.2
+     *
+     * A Multi-Status response conveys information about multiple resources in situations where multiple status codes
+     * might be appropriate.
+     */
+    readonly MULTI_STATUS: 207;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.1
+     *
+     * The request has more than one possible responses. User-agent or user should choose one of them. There is no
+     * standardized way to choose one of the responses.
+     */
+    readonly MULTIPLE_CHOICES: 300;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.2
+     *
+     * This response code means that URI of requested resource has been changed. Probably, new URI would be given in the
+     * response.
+     */
+    readonly MOVED_PERMANENTLY: 301;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.3
+     *
+     * This response code means that URI of requested resource has been changed temporarily. New changes in the URI might
+     * be made in the future. Therefore, this same URI should be used by the client in future requests.
+     */
+    readonly MOVED_TEMPORARILY: 302;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.4
+     *
+     * Server sent this response to directing client to get requested resource to another URI with an GET request.
+     */
+    readonly SEE_OTHER: 303;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7232#section-4.1
+     *
+     * This is used for caching purposes. It is telling to client that response has not been modified. So, client can
+     * continue to use same cached version of response.
+     */
+    readonly NOT_MODIFIED: 304;
+    /**
+     * @deprecated
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.6
+     *
+     * Was defined in a previous version of the HTTP specification to indicate that a requested response must be accessed
+     *   by a proxy. It has been deprecated due to security concerns regarding in-band configuration of a proxy.
+     */
+    readonly USE_PROXY: 305;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.4.7
+     *
+     * Server sent this response to directing client to get requested resource to another URI with same method that used
+     * prior request. This has the same semantic as the 302 Found HTTP response code, with the exception that the user
+     * agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the
+     * second request.
+     */
+    readonly TEMPORARY_REDIRECT: 307;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7538#section-3
+     *
+     * This means that the resource is now permanently located at another URI, specified by the Location: HTTP Response
+     * header. This has the same semantics as the 301 Moved Permanently HTTP response code, with the exception that the
+     * user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in
+     * the second request.
+     */
+    readonly PERMANENT_REDIRECT: 308;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.1
+     *
+     * This response means that server could not understand the request due to invalid syntax.
+     */
+    readonly BAD_REQUEST: 400;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7235#section-3.1
+     *
+     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is,
+     * the client must authenticate itself to get the requested response.
+     */
+    readonly UNAUTHORIZED: 401;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.2
+     *
+     * This response code is reserved for future use. Initial aim for creating this code was using it for digital payment
+     * systems however this is not used currently.
+     */
+    readonly PAYMENT_REQUIRED: 402;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.3
+     *
+     * The client does not have access rights to the content, i.e. they are unauthorized, so server is rejecting to give
+     * proper response. Unlike 401, the client's identity is known to the server.
+     */
+    readonly FORBIDDEN: 403;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.4
+     *
+     * The server can not find requested resource. In the browser, this means the URL is not recognized. In an API, this
+     * can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this
+     * response instead of 403 to hide the existence of a resource from an unauthorized client. This response code is
+     * probably the most famous one due to its frequent occurrence on the web.
+     */
+    readonly NOT_FOUND: 404;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.5
+     *
+     * The request method is known by the server but has been disabled and cannot be used. For example, an API may forbid
+     * DELETE-ing a resource. The two mandatory methods, GET and HEAD, must never be disabled and should not return this
+     * error code.
+     */
+    readonly METHOD_NOT_ALLOWED: 405;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.6
+     *
+     * This response is sent when the web server, after performing server-driven content negotiation, doesn't find any
+     * content following the criteria given by the user agent.
+     */
+    readonly NOT_ACCEPTABLE: 406;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7235#section-3.2
+     *
+     * This is similar to 401 but authentication is needed to be done by a proxy.
+     */
+    readonly PROXY_AUTHENTICATION_REQUIRED: 407;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.7
+     *
+     * This response is sent on an idle connection by some servers, even without any previous request by the client. It
+     * means that the server would like to shut down this unused connection. This response is used much more since some
+     * browsers, like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing. Also note that
+     * some servers merely shut down the connection without sending this message.
+     */
+    readonly REQUEST_TIMEOUT: 408;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.8
+     *
+     * This response is sent when a request conflicts with the current state of the server.
+     */
+    readonly CONFLICT: 409;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.9
+     *
+     * This response would be sent when the requested content has been permanently deleted from server, with no
+     * forwarding address. Clients are expected to remove their caches and links to the resource. The HTTP specification
+     * intends this status code to be used for "limited-time, promotional services". APIs should not feel compelled to
+     * indicate resources that have been deleted with this status code.
+     */
+    readonly GONE: 410;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.10
+     *
+     * The server rejected the request because the Content-Length header field is not defined and the server requires it.
+     */
+    readonly LENGTH_REQUIRED: 411;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7232#section-4.2
+     *
+     * The client has indicated preconditions in its headers which the server does not meet.
+     */
+    readonly PRECONDITION_FAILED: 412;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.11
+     *
+     * Request entity is larger than limits defined by server; the server might close the connection or return a
+     * Retry-After header field.
+     */
+    readonly REQUEST_TOO_LONG: 413;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.12
+     *
+     * The URI requested by the client is longer than the server is willing to interpret.
+     */
+    readonly REQUEST_URI_TOO_LONG: 414;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.13
+     *
+     * The media format of the requested data is not supported by the server, so the server is rejecting the request.
+     */
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7233#section-4.4
+     *
+     * The range specified by the Range header field in the request can't be fulfilled; it's possible that the range is
+     * outside the size of the target URI's data.
+     */
+    readonly REQUESTED_RANGE_NOT_SATISFIABLE: 416;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.5.14
+     *
+     * This response code means the expectation indicated by the Expect request header field can't be met by the server.
+     */
+    readonly EXPECTATION_FAILED: 417;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2324#section-2.3.2
+     *
+     * Any attempt to brew coffee with a teapot should result in the error code "418 I'm a teapot". The resulting entity
+     * body MAY be short and stout.
+     */
+    readonly IM_A_TEAPOT: 418;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.6
+     *
+     * The 507 (Insufficient Storage) status code means the method could not be performed on the resource because the
+     * server is unable to store the representation needed to successfully complete the request. This condition is
+     * considered to be temporary. If the request which received this status code was the result of a user action, the
+     * request MUST NOT be repeated until it is requested by a separate user action.
+     */
+    readonly INSUFFICIENT_SPACE_ON_RESOURCE: 419;
+    /**
+     * @deprecated
+     * Official Documentation: https://tools.ietf.org/rfcdiff?difftype=--hwdiff&url2=draft-ietf-webdav-protocol-06.txt
+     *
+     * A deprecated response used by the Spring Framework when a method has failed.
+     */
+    readonly METHOD_FAILURE: 420;
+    /**
+     * Official Documentation: https://datatracker.ietf.org/doc/html/rfc7540#section-9.1.2
+     *
+     * Defined in the specification of HTTP/2 to indicate that a server is not able to produce a response for the
+     * combination of scheme and authority that are included in the request URI.
+     */
+    readonly MISDIRECTED_REQUEST: 421;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.3
+     *
+     * The request was well-formed but was unable to be followed due to semantic errors.
+     */
+    readonly UNPROCESSABLE_ENTITY: 422;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.4
+     *
+     * The resource that is being accessed is locked.
+     */
+    readonly LOCKED: 423;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.5
+     *
+     * The request failed due to failure of a previous request.
+     */
+    readonly FAILED_DEPENDENCY: 424;
+    /**
+     * Official Documentation: https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.15
+     *
+     * The server refuses to perform the request using the current protocol but might be willing to do so after the
+     * client upgrades to a different protocol.
+     */
+    readonly UPGRADE_REQUIRED: 426;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc6585#section-3
+     *
+     * The origin server requires the request to be conditional. Intended to prevent the 'lost update' problem, where a
+     * client GETs a resource's state, modifies it, and PUTs it back to the server, when meanwhile a third party has
+     * modified the state on the server, leading to a conflict.
+     */
+    readonly PRECONDITION_REQUIRED: 428;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc6585#section-4
+     *
+     * The user has sent too many requests in a given amount of time ("rate limiting").
+     */
+    readonly TOO_MANY_REQUESTS: 429;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc6585#section-5
+     *
+     * The server is unwilling to process the request because its header fields are too large. The request MAY be
+     * resubmitted after reducing the size of the request header fields.
+     */
+    readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7725
+     *
+     * The user-agent requested a resource that cannot legally be provided, such as a web page censored by a government.
+     */
+    readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.1
+     *
+     * The server encountered an unexpected condition that prevented it from fulfilling the request.
+     */
+    readonly INTERNAL_SERVER_ERROR: 500;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.2
+     *
+     * The request method is not supported by the server and cannot be handled. The only methods that servers are
+     * required to support (and therefore that must not return this code) are GET and HEAD.
+     */
+    readonly NOT_IMPLEMENTED: 501;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.3
+     *
+     * This error response means that the server, while working as a gateway to get a response needed to handle the
+     * request, got an invalid response.
+     */
+    readonly BAD_GATEWAY: 502;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.4
+     *
+     * The server is not ready to handle the request. Common causes are a server that is down for maintenance or that is
+     * overloaded. Note that together with this response, a user-friendly page explaining the problem should be sent.
+     * This responses should be used for temporary conditions and the Retry-After: HTTP header should, if possible,
+     * contain the estimated time before the recovery of the service. The webmaster must also take care about the
+     * caching-related headers that are sent along with this response, as these temporary condition responses should
+     * usually not be cached.
+     */
+    readonly SERVICE_UNAVAILABLE: 503;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.5
+     *
+     * This error response is given when the server is acting as a gateway and cannot get a response in time.
+     */
+    readonly GATEWAY_TIMEOUT: 504;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc7231#section-6.6.6
+     *
+     * The HTTP version used in the request is not supported by the server.
+     */
+    readonly HTTP_VERSION_NOT_SUPPORTED: 505;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc2518#section-10.6
+     *
+     * The server has an internal configuration error: the chosen variant resource is configured to engage in transparent
+     * content negotiation itself, and is therefore not a proper end point in the negotiation process.
+     */
+    readonly INSUFFICIENT_STORAGE: 507;
+    /**
+     * Official Documentation: https://tools.ietf.org/html/rfc6585#section-6
+     *
+     * The 511 status code indicates that the client needs to authenticate to gain network access.
+     */
+    readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
+};
+export type HttpStatusCode = (typeof HttpStatus)[keyof typeof HttpStatus];

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

@@ -1,4 +1,5 @@
 import { IntegrationId } from './communication.public-types';
+export declare const AI_AGENTS_INTEGRATION_ID = "ai_agents";
 /** List of all integration types supported by Squid. */
 export declare const INTEGRATION_TYPES: readonly ["active_directory", "ai_agents", "ai_chatbot", "algolia", "alloydb", "api", "auth0", "azure_cosmosdb", "azure_postgresql", "azure_sql", "bigquery", "built_in_db", "built_in_gcs", "built_in_queue", "built_in_s3", "cassandra", "clickhouse", "cloudsql", "cockroach", "cognito", "confluence", "confluent", "datadog", "db2", "descope", "documentdb", "dynamodb", "elastic_enterprise_search", "elastic_observability", "elastic_search", "firebase_auth", "firestore", "gcs", "google_docs", "google_drive", "graphql", "hubspot", "jira", "jwt_hmac", "jwt_rsa", "kafka", "linear", "mariadb", "monday", "mongo", "mssql", "mysql", "newrelic", "okta", "onedrive", "oracledb", "pinecone", "postgres", "redis", "s3", "salesforce_crm", "sap_hana", "sentry", "servicenow", "snowflake", "spanner", "xata", "zendesk", "mail", "slack"];
 export declare const DATA_INTEGRATION_TYPES: readonly ["bigquery", "built_in_db", "clickhouse", "cockroach", "mongo", "mssql", "mysql", "oracledb", "postgres", "sap_hana", "snowflake"];
@@ -10,7 +11,6 @@ export declare const INTEGRATION_SCHEMA_TYPES: readonly ["data", "api", "graphql
 export type IntegrationSchemaType = (typeof INTEGRATION_SCHEMA_TYPES)[number];
 export declare const BUILT_IN_DB_INTEGRATION_ID: IntegrationId;
 export declare const BUILT_IN_QUEUE_INTEGRATION_ID: IntegrationId;
-export declare const AI_AGENTS_INTEGRATION_ID: IntegrationId;
 /** ID for the cloud specific storage integration: s3 (built_in_s3) or gcs (built_in_gcs). */
 export declare const BUILT_IN_STORAGE_INTEGRATION_ID: IntegrationId;
 export interface IntegrationInfo<ConfigurationType = Record<string, any> | undefined> {

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

@@ -33,6 +33,7 @@ export interface SimpleCondition<Doc extends DocumentData = any, F extends Paths
 export interface CompositeCondition<Doc extends DocumentData = any> {
     fields: Array<SimpleCondition<Doc, Paths<Doc>, CompositeConditionOperator>>;
 }
+/** Returns true if the condition is a 'SimpleCondition' or false otherwise. */
 export declare function isSimpleCondition(condition: Condition): condition is SimpleCondition;
 type CompositeConditionOperator = '>=' | '<=' | '>' | '<';
 export declare const ARRAY_OPERATORS: readonly ["in", "not in", "array_includes_some", "array_includes_all", "array_not_includes"];

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

@@ -1,5 +1,3 @@
-export declare enum ClientConnectionState {
-    CONNECTED = "CONNECTED",
-    DISCONNECTED = "DISCONNECTED",
-    REMOVED = "REMOVED"
-}
+export declare const CLIENT_CONNECTION_STATES: readonly ["CONNECTED", "DISCONNECTED", "REMOVED"];
+/** Squid client connection state. */
+export type ClientConnectionState = (typeof CLIENT_CONNECTION_STATES)[number];

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

@@ -1,32 +1 @@
-import { AiChatPromptQuotas, AiConnectedAgentMetadata, AiConnectedIntegrationMetadata, AiFileUrl } from '../public-types/ai-agent.public-types';
-import { AiAgentId } from '../public-types/communication.public-types';
-import { FunctionName, FunctionNameWithContext } from '../public-types/bundle-data.public-types';
-export type AiChatResponseFormat = 'text' | 'json_object';
-export interface AiChatOptions {
-    maxTokens: number;
-    responseFormat: AiChatResponseFormat;
-    temperature: number;
-    topP: number;
-    instructions: Array<string>;
-    clientId: string;
-    fileUrls: Array<AiFileUrl>;
-    /** Constrains effort on reasoning for reasoning models. o1 models only. */
-    reasoningEffort?: 'low' | 'medium' | 'high';
-    /** Current AI profile ID (AI agent ID). */
-    agentId?: AiAgentId;
-    /** A unique chat ID for the conversation. */
-    chatId?: string;
-    /** Global per-agent context passed to all AI functions. Must be a serializable JSON. */
-    agentContext?: Record<string, unknown>;
-    /** List of AI functions available for the agent. Overrides the stored list.*/
-    functions?: Array<FunctionName | FunctionNameWithContext>;
-    /** List of connected AI agents can be called by the current agent. Overrides the stored list.*/
-    connectedAgents?: Array<AiConnectedAgentMetadata>;
-    /** List of connected integrations. Overrides the stored list. */
-    connectedIntegrations?: Array<AiConnectedIntegrationMetadata>;
-    /** Current budget for nested or recursive AI chat calls per single prompt. */
-    quotas?: AiChatPromptQuotas;
-    /** Enables grounding with real-time web search to enhance AI responses with up-to-date information.
-     * Currently supported only for gemini-2.0-flash. */
-    groundingWithWebSearch?: boolean;
-}
+export {};

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

@@ -38,7 +38,7 @@ export interface LogEvent {
     source?: string;
     service?: string;
 }
-export declare const AUDIT_LOG_EVENT_NAMES: readonly ["ai_agent_prompt"];
+export declare const AUDIT_LOG_EVENT_NAMES: readonly ["ai_agent"];
 export type AuditLogEventName = (typeof AUDIT_LOG_EVENT_NAMES)[number];
 export interface AuditLogEvent {
     appId: AppId;

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

@@ -1,9 +1,8 @@
-import { HttpStatus } from '../public-types/http-status.enum';
-export type StatusCode = HttpStatus.BAD_REQUEST | HttpStatus.NOT_FOUND | HttpStatus.FORBIDDEN | HttpStatus.UNAUTHORIZED | HttpStatus.CONFLICT | HttpStatus.INTERNAL_SERVER_ERROR;
+import { HttpStatusCode } from '../public-types/http-status.enum';
 export declare class ValidationError extends Error {
-    readonly statusCode: StatusCode;
+    readonly statusCode: HttpStatusCode;
     readonly details?: any;
-    constructor(error: string, statusCode: StatusCode, details?: Record<string, any>);
+    constructor(error: string, statusCode: HttpStatusCode, details?: Record<string, any>);
 }
 export declare function isValidId(id: unknown, maxLength?: number): boolean;
 export declare function validateFieldSort(fieldSort: unknown): void;

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

@@ -1,14 +1,11 @@
 import { IntegrationClient } from './integration-client';
 import { SecretClient } from './secret.client';
-import { AgentClient } from './agent-client';
 export declare class AdminClient {
     private readonly rpcManager;
     private readonly region;
     private readonly appId;
     private readonly integrationClient;
     private readonly secretClient;
-    private readonly agentClient;
     integrations(): IntegrationClient;
     secrets(): SecretClient;
-    agents(): AgentClient;
 }

package/dist/typescript-client/src/agent/ai-agent-client-reference.d.ts

@@ -0,0 +1,36 @@
+import { AgentContextRequest, AiAgent, AiAgentChatOptions, AiAgentContext, AiChatModelName, AiConnectedAgentMetadata, AiObserveStatusOptions, AiSearchOptions, AiSearchResponse, AiStatusMessage, AiTranscribeAndAskResponse, UpsertAgentRequest } from '../../../internal-common/src/public-types/ai-agent.public-types';
+import { BlobAndFilename } from '../types';
+import { Observable } from 'rxjs';
+import { AskOptionsWithoutVoice, AskWithVoiceResponse, ChatOptionsWithoutVoice, TranscribeAndAskWithVoiceResponse, TranscribeAndChatResponse } from './ai-agent-client.types';
+export type UpsertAgentRequestParams = Omit<UpsertAgentRequest, 'id'>;
+export declare class AiAgentReference {
+    private readonly agentId;
+    private readonly ongoingChatSequences;
+    private readonly statusUpdates;
+    private readonly rpcManager;
+    get(): Promise<AiAgent | undefined>;
+    upsert(agent: UpsertAgentRequestParams): Promise<void>;
+    delete(): Promise<void>;
+    updateInstructions(instructions: string): Promise<void>;
+    updateModel(model: AiChatModelName): Promise<void>;
+    updateConnectedAgents(connectedAgents: Array<AiConnectedAgentMetadata>): Promise<void>;
+    getContext(contextId: string): Promise<AiAgentContext | undefined>;
+    listContexts(): Promise<Array<AiAgentContext>>;
+    deleteContext(contextId: string): Promise<void>;
+    deleteContexts(contextIds: Array<string>): Promise<void>;
+    upsertContext(contextRequest: AgentContextRequest, file?: File | BlobAndFilename): Promise<void>;
+    upsertContexts(contextRequests: Array<AgentContextRequest>, files?: Array<File | BlobAndFilename>): Promise<void>;
+    provideFeedback(feedback: string): Promise<void>;
+    resetFeedback(): Promise<void>;
+    chat(prompt: string, options?: ChatOptionsWithoutVoice): Observable<string>;
+    transcribeAndChat(fileToTranscribe: File, options?: ChatOptionsWithoutVoice): Promise<TranscribeAndChatResponse>;
+    search(options: AiSearchOptions): Promise<AiSearchResponse>;
+    ask(prompt: string, options?: AskOptionsWithoutVoice): Promise<string>;
+    observeStatusUpdates(options?: AiObserveStatusOptions): Observable<AiStatusMessage>;
+    transcribeAndAsk(fileToTranscribe: File, options?: AskOptionsWithoutVoice): Promise<AiTranscribeAndAskResponse>;
+    transcribeAndAskWithVoiceResponse(fileToTranscribe: File, options?: Omit<AiAgentChatOptions, 'smoothTyping'>): Promise<TranscribeAndAskWithVoiceResponse>;
+    askWithVoiceResponse(prompt: string, options?: Omit<AiAgentChatOptions, 'smoothTyping'>): Promise<AskWithVoiceResponse>;
+    private askInternal;
+    private createStatusSubject;
+    private chatInternal;
+}

package/dist/typescript-client/src/agent/ai-agent-client.d.ts

@@ -0,0 +1,13 @@
+import { AiAgent, AiAgentId } from '../public-types';
+import { AiAgentReference } from './ai-agent-client-reference';
+export declare class AiAgentClient {
+    private readonly rpcManager;
+    private readonly socketManager;
+    private readonly ongoingChatSequences;
+    private readonly statusUpdates;
+    agent(id: AiAgentId): AiAgentReference;
+    listAgents(): Promise<Array<AiAgent>>;
+    private handleChatResponse;
+    private handleStatusMessage;
+    private getStatusSubject;
+}

package/dist/typescript-client/src/agent/ai-agent-client.types.d.ts

@@ -0,0 +1,17 @@
+import { AiAgentChatOptions } from '../../../internal-common/src/public-types/ai-agent.public-types';
+import { Observable } from 'rxjs';
+export interface TranscribeAndChatResponse {
+    transcribedPrompt: string;
+    responseStream: Observable<string>;
+}
+export interface TranscribeAndAskWithVoiceResponse {
+    transcribedPrompt: string;
+    responseString: string;
+    voiceResponseFile: File;
+}
+export interface AskWithVoiceResponse {
+    responseString: string;
+    voiceResponseFile: File;
+}
+export type ChatOptionsWithoutVoice = Omit<AiAgentChatOptions, 'voiceOptions'>;
+export type AskOptionsWithoutVoice = Omit<AiAgentChatOptions, 'voiceOptions' | 'smoothTyping'>;