@anduril-industries/lattice-sdk 4.4.1 → 4.6.0

package/dist/cjs/BaseClient.js

@@ -43,8 +43,8 @@ function normalizeClientOptions(options) {
     const headers = (0, headers_js_1.mergeHeaders)({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "@anduril-industries/lattice-sdk",
-        "X-Fern-SDK-Version": "4.4.1",
-        "User-Agent": "@anduril-industries/lattice-sdk/4.4.1",
+        "X-Fern-SDK-Version": "4.6.0",
+        "User-Agent": "@anduril-industries/lattice-sdk/4.6.0",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/cjs/api/resources/tasks/client/Client.d.ts

@@ -93,12 +93,11 @@ export declare class TasksClient {
      * This method initiates task cancellation based on the task's current state:
      * - If the task has not been sent to an agent, it cancels immediately and transitions the task
      *   to a terminal state (`STATUS_DONE_NOT_OK` with `ERROR_CODE_CANCELLED`).
-     * - If the task has already been sent to an agent, the cancellation request is routed to the agent with a delivery status of `DELIVERY_STATUS_PENDING_CANCEL`.
-     *   The agent is responsible for determining whether cancellation is possible and updating
-     *   the task status accordingly via the `UpdateStatus` endpoint:
-     *   - If the task can be cancelled, the agent should update the task status to `STATUS_DONE_NOT_OK`.
-     *   - If the task cannot be cancelled, the agent should attach an error to the task stating why cancellation is not possible using `UpdateStatus`
-     *     or the returned task object.
+     * - If the task has already been sent to an agent, the cancellation request is routed to the agent.
+     *   The agent is then responsible for deciding whether cancellation is possible or not:
+     *   - If the task can be cancelled, the agent must use `UpdateTaskStatus` and set the task status to `STATUS_DONE_NOT_OK`.
+     *   - If the task cannot be cancelled, the agent must use `UpdateTaskStatus` to attach a `TaskError` to the task with the error code `ERROR_CODE_REJECTED`
+     *     and a `message` explaining why the task cannot be cancelled.
      *
      * @param {Lattice.TaskCancellation} request
      * @param {TasksClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -209,4 +208,23 @@ export declare class TasksClient {
      */
     streamAsAgent(request?: Lattice.AgentStreamRequest, requestOptions?: TasksClient.RequestOptions): core.HttpResponsePromise<core.Stream<Lattice.StreamAsAgentResponse>>;
     private __streamAsAgent;
+    /**
+     * @beta This endpoint is in pre-release and may change.
+     *
+     * Establishes a server streaming connection that delivers manual control frames to agents
+     * using server-sent events (SSE).
+     *
+     * This endpoint streams manual control frames, for example, for joystick movements, for a specific task
+     * to the executing agent. The agent should open this stream before reporting `STATUS_EXECUTING`
+     * to ensure it is ready to receive control input when the operator begins sending frames.
+     *
+     * Each frame includes epoch and sequence metadata for handling concurrent control sessions
+     * and detecting stale or out-of-order frames. Heartbeat messages are sent periodically to
+     * maintain the connection.
+     *
+     * The stream terminates automatically when the task reaches a terminal state
+     * (`STATUS_DONE_OK` or `STATUS_DONE_NOT_OK`).
+     */
+    streamManualControlFrames(request: Lattice.ManualControlStreamRequest, requestOptions?: TasksClient.RequestOptions): core.HttpResponsePromise<core.Stream<Lattice.StreamManualControlFramesResponse>>;
+    private __streamManualControlFrames;
 }

package/dist/cjs/api/resources/tasks/client/Client.js

@@ -272,12 +272,11 @@ class TasksClient {
      * This method initiates task cancellation based on the task's current state:
      * - If the task has not been sent to an agent, it cancels immediately and transitions the task
      *   to a terminal state (`STATUS_DONE_NOT_OK` with `ERROR_CODE_CANCELLED`).
-     * - If the task has already been sent to an agent, the cancellation request is routed to the agent with a delivery status of `DELIVERY_STATUS_PENDING_CANCEL`.
-     *   The agent is responsible for determining whether cancellation is possible and updating
-     *   the task status accordingly via the `UpdateStatus` endpoint:
-     *   - If the task can be cancelled, the agent should update the task status to `STATUS_DONE_NOT_OK`.
-     *   - If the task cannot be cancelled, the agent should attach an error to the task stating why cancellation is not possible using `UpdateStatus`
-     *     or the returned task object.
+     * - If the task has already been sent to an agent, the cancellation request is routed to the agent.
+     *   The agent is then responsible for deciding whether cancellation is possible or not:
+     *   - If the task can be cancelled, the agent must use `UpdateTaskStatus` and set the task status to `STATUS_DONE_NOT_OK`.
+     *   - If the task cannot be cancelled, the agent must use `UpdateTaskStatus` to attach a `TaskError` to the task with the error code `ERROR_CODE_REJECTED`
+     *     and a `message` explaining why the task cannot be cancelled.
      *
      * @param {Lattice.TaskCancellation} request
      * @param {TasksClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -615,5 +614,76 @@ class TasksClient {
             return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/api/v1/agent/stream");
         });
     }
+    /**
+     * @beta This endpoint is in pre-release and may change.
+     *
+     * Establishes a server streaming connection that delivers manual control frames to agents
+     * using server-sent events (SSE).
+     *
+     * This endpoint streams manual control frames, for example, for joystick movements, for a specific task
+     * to the executing agent. The agent should open this stream before reporting `STATUS_EXECUTING`
+     * to ensure it is ready to receive control input when the operator begins sending frames.
+     *
+     * Each frame includes epoch and sequence metadata for handling concurrent control sessions
+     * and detecting stale or out-of-order frames. Heartbeat messages are sent periodically to
+     * maintain the connection.
+     *
+     * The stream terminates automatically when the task reaches a terminal state
+     * (`STATUS_DONE_OK` or `STATUS_DONE_NOT_OK`).
+     */
+    streamManualControlFrames(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__streamManualControlFrames(request, requestOptions));
+    }
+    __streamManualControlFrames(request, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const { taskId } = request, _body = __rest(request, ["taskId"]);
+            const _authRequest = yield this._options.authProvider.getAuthRequest();
+            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _response = yield core.fetcher({
+                url: core.url.join((_c = (_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.LatticeEnvironment.Default, `api/v1/tasks/${core.url.encodePathParam(taskId)}/manual-control/stream`),
+                method: "POST",
+                headers: _headers,
+                contentType: "application/json",
+                queryParameters: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.queryParams,
+                requestType: "json",
+                body: _body,
+                responseType: "sse",
+                timeoutMs: ((_f = (_d = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) !== null && _d !== void 0 ? _d : (_e = this._options) === null || _e === void 0 ? void 0 : _e.timeoutInSeconds) !== null && _f !== void 0 ? _f : 60) * 1000,
+                maxRetries: (_g = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries) !== null && _g !== void 0 ? _g : (_h = this._options) === null || _h === void 0 ? void 0 : _h.maxRetries,
+                abortSignal: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal,
+                fetchFn: (_j = this._options) === null || _j === void 0 ? void 0 : _j.fetch,
+                logging: this._options.logging,
+            });
+            if (_response.ok) {
+                return {
+                    data: new core.Stream({
+                        stream: _response.body,
+                        parse: (data) => data,
+                        signal: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal,
+                        eventShape: {
+                            type: "sse",
+                        },
+                    }),
+                    rawResponse: _response.rawResponse,
+                };
+            }
+            if (_response.error.reason === "status-code") {
+                switch (_response.error.statusCode) {
+                    case 400:
+                        throw new Lattice.BadRequestError(_response.error.body, _response.rawResponse);
+                    case 401:
+                        throw new Lattice.UnauthorizedError(_response.error.body, _response.rawResponse);
+                    default:
+                        throw new errors.LatticeError({
+                            statusCode: _response.error.statusCode,
+                            body: _response.error.body,
+                            rawResponse: _response.rawResponse,
+                        });
+                }
+            }
+            return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/api/v1/tasks/{taskId}/manual-control/stream");
+        });
+    }
 }
 exports.TasksClient = TasksClient;

package/dist/cjs/api/resources/tasks/client/requests/ManualControlStreamRequest.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @example
+ *     {
+ *         taskId: "taskId"
+ *     }
+ */
+export interface ManualControlStreamRequest {
+    /** The ID of the manual control task to receive frames for. */
+    taskId: string;
+    /** The time interval, in milliseconds, that determines the frequency at which to send heartbeat events. Defaults to 30000 (30 seconds). */
+    heartbeatIntervalMs?: number;
+}

package/dist/cjs/api/resources/tasks/client/requests/ManualControlStreamRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+//  This file was auto-generated from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/resources/tasks/client/requests/TaskStreamRequest.d.ts

@@ -1,3 +1,4 @@
+import type * as Lattice from "../../../../index.js";
 /**
  * @example
  *     {}
@@ -17,6 +18,18 @@ export interface TaskStreamRequest {
     excludePreexistingTasks?: boolean;
     /** Optional filter that only returns tasks with specific types. If not provided, all task types will be streamed. */
     taskType?: TaskStreamRequest.TaskType;
+    /** If provided, returns tasks which have been updated since the given time. */
+    updateStartTime?: Lattice.Timestamp;
+    /**
+     * A filter for tasks with a specific parent task ID.
+     * Note: This filter is mutually exclusive with all other filter fields (`updateStartTime`, `assignee`, `statusFilter`, `taskType`).
+     * Either provide `parentTaskId` or any combination of the other filters, but not both.
+     */
+    parentTaskId?: string;
+    /** A filter for tasks assigned to a specific principal. */
+    assignee?: Lattice.Principal;
+    /** A filter for task statuses (inclusive or exclusive). */
+    statusFilter?: TaskStreamRequest.StatusFilter;
 }
 export declare namespace TaskStreamRequest {
     /**
@@ -27,4 +40,43 @@ export declare namespace TaskStreamRequest {
     } | {
         taskTypePrefix: string;
     };
+    /**
+     * A filter for task statuses (inclusive or exclusive).
+     */
+    interface StatusFilter {
+        /** The statuses to filter by. */
+        statuses?: StatusFilter.Statuses.Item[] | undefined;
+        /** The type of filter to apply. */
+        filterType?: StatusFilter.FilterType | undefined;
+    }
+    namespace StatusFilter {
+        type Statuses = Statuses.Item[];
+        namespace Statuses {
+            const Item: {
+                readonly StatusInvalid: "STATUS_INVALID";
+                readonly StatusCreated: "STATUS_CREATED";
+                readonly StatusScheduledInManager: "STATUS_SCHEDULED_IN_MANAGER";
+                readonly StatusSent: "STATUS_SENT";
+                readonly StatusMachineReceipt: "STATUS_MACHINE_RECEIPT";
+                readonly StatusAck: "STATUS_ACK";
+                readonly StatusWilco: "STATUS_WILCO";
+                readonly StatusExecuting: "STATUS_EXECUTING";
+                readonly StatusWaitingForUpdate: "STATUS_WAITING_FOR_UPDATE";
+                readonly StatusDoneOk: "STATUS_DONE_OK";
+                readonly StatusDoneNotOk: "STATUS_DONE_NOT_OK";
+                readonly StatusReplaced: "STATUS_REPLACED";
+                readonly StatusCancelRequested: "STATUS_CANCEL_REQUESTED";
+                readonly StatusCompleteRequested: "STATUS_COMPLETE_REQUESTED";
+                readonly StatusVersionRejected: "STATUS_VERSION_REJECTED";
+            };
+            type Item = (typeof Item)[keyof typeof Item];
+        }
+        /** The type of filter to apply. */
+        const FilterType: {
+            readonly FilterTypeInvalid: "FILTER_TYPE_INVALID";
+            readonly FilterTypeInclusive: "FILTER_TYPE_INCLUSIVE";
+            readonly FilterTypeExclusive: "FILTER_TYPE_EXCLUSIVE";
+        };
+        type FilterType = (typeof FilterType)[keyof typeof FilterType];
+    }
 }

package/dist/cjs/api/resources/tasks/client/requests/TaskStreamRequest.js

@@ -1,3 +1,36 @@
 "use strict";
 //  This file was auto-generated from our API Definition.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStreamRequest = void 0;
+var TaskStreamRequest;
+(function (TaskStreamRequest) {
+    let StatusFilter;
+    (function (StatusFilter) {
+        let Statuses;
+        (function (Statuses) {
+            Statuses.Item = {
+                StatusInvalid: "STATUS_INVALID",
+                StatusCreated: "STATUS_CREATED",
+                StatusScheduledInManager: "STATUS_SCHEDULED_IN_MANAGER",
+                StatusSent: "STATUS_SENT",
+                StatusMachineReceipt: "STATUS_MACHINE_RECEIPT",
+                StatusAck: "STATUS_ACK",
+                StatusWilco: "STATUS_WILCO",
+                StatusExecuting: "STATUS_EXECUTING",
+                StatusWaitingForUpdate: "STATUS_WAITING_FOR_UPDATE",
+                StatusDoneOk: "STATUS_DONE_OK",
+                StatusDoneNotOk: "STATUS_DONE_NOT_OK",
+                StatusReplaced: "STATUS_REPLACED",
+                StatusCancelRequested: "STATUS_CANCEL_REQUESTED",
+                StatusCompleteRequested: "STATUS_COMPLETE_REQUESTED",
+                StatusVersionRejected: "STATUS_VERSION_REJECTED",
+            };
+        })(Statuses = StatusFilter.Statuses || (StatusFilter.Statuses = {}));
+        /** The type of filter to apply. */
+        StatusFilter.FilterType = {
+            FilterTypeInvalid: "FILTER_TYPE_INVALID",
+            FilterTypeInclusive: "FILTER_TYPE_INCLUSIVE",
+            FilterTypeExclusive: "FILTER_TYPE_EXCLUSIVE",
+        };
+    })(StatusFilter = TaskStreamRequest.StatusFilter || (TaskStreamRequest.StatusFilter = {}));
+})(TaskStreamRequest || (exports.TaskStreamRequest = TaskStreamRequest = {}));

package/dist/cjs/api/resources/tasks/client/requests/index.d.ts

@@ -1,8 +1,9 @@
 export type { AgentListener } from "./AgentListener.js";
 export type { AgentStreamRequest } from "./AgentStreamRequest.js";
 export type { GetTaskRequest } from "./GetTaskRequest.js";
+export type { ManualControlStreamRequest } from "./ManualControlStreamRequest.js";
 export type { TaskCancellation } from "./TaskCancellation.js";
 export type { TaskCreation } from "./TaskCreation.js";
 export { TaskQuery } from "./TaskQuery.js";
 export type { TaskStatusUpdate } from "./TaskStatusUpdate.js";
-export type { TaskStreamRequest } from "./TaskStreamRequest.js";
+export { TaskStreamRequest } from "./TaskStreamRequest.js";

package/dist/cjs/api/resources/tasks/client/requests/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskQuery = void 0;
+exports.TaskStreamRequest = exports.TaskQuery = void 0;
 var TaskQuery_js_1 = require("./TaskQuery.js");
 Object.defineProperty(exports, "TaskQuery", { enumerable: true, get: function () { return TaskQuery_js_1.TaskQuery; } });
+var TaskStreamRequest_js_1 = require("./TaskStreamRequest.js");
+Object.defineProperty(exports, "TaskStreamRequest", { enumerable: true, get: function () { return TaskStreamRequest_js_1.TaskStreamRequest; } });

package/dist/cjs/api/resources/tasks/types/StreamManualControlFramesResponse.d.ts

@@ -0,0 +1,13 @@
+import type * as Lattice from "../../../index.js";
+/**
+ * The stream event response.
+ */
+export type StreamManualControlFramesResponse = Lattice.StreamManualControlFramesResponse.Heartbeat | Lattice.StreamManualControlFramesResponse.ManualControlFrame;
+export declare namespace StreamManualControlFramesResponse {
+    interface Heartbeat extends Lattice.StreamHeartbeat {
+        event: "heartbeat";
+    }
+    interface ManualControlFrame extends Lattice.ManualControlFrameEvent {
+        event: "manual_control_frame";
+    }
+}

package/dist/cjs/api/resources/tasks/types/StreamManualControlFramesResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+//  This file was auto-generated from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/resources/tasks/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./StreamAsAgentResponse.js";
+export * from "./StreamManualControlFramesResponse.js";
 export * from "./StreamTasksResponse.js";

package/dist/cjs/api/resources/tasks/types/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./StreamAsAgentResponse.js"), exports);
+__exportStar(require("./StreamManualControlFramesResponse.js"), exports);
 __exportStar(require("./StreamTasksResponse.js"), exports);

package/dist/cjs/api/types/ManualControlFrame.d.ts

@@ -0,0 +1,38 @@
+import type * as Lattice from "../index.js";
+/**
+ * A single frame of manual control input forwarded by Lattice to an agent.
+ *
+ *  When an operator sends manual control input, for example, joystick movements using
+ *  `SendManualControlFrames`, Lattice packages each input into a `ManualControlFrame`
+ *  and forwards it to the executing agent via the `ListenForManualControlFrames`
+ *  streaming RPC.
+ *
+ *  Each frame carries sequencing metadata to support concurrent control sessions,
+ *  detect stale frames, and ensure proper ordering.
+ */
+export interface ManualControlFrame {
+    /** The ID of the manual control task this frame belongs to. */
+    taskId?: string | undefined;
+    /**
+     * Unix timestamp in microseconds identifying the control session.
+     *  Increments each time a client opens a new stream for this task.
+     *  Agents should ignore frames with a lower epoch to handle stale streams
+     *  or operator handoffs.
+     */
+    epochMicros?: string | undefined;
+    /**
+     * The sequence number for a stream, incremented for each frame.
+     *  Agents can use this to detect out-of-order delivery within the same epoch.
+     */
+    sequence?: string | undefined;
+    /**
+     * The time at which this frame was created.
+     *  Agents can use this to detect stale frame data.
+     */
+    creationTime?: string | undefined;
+    /**
+     * The control instructions for this frame, passed through from the client.
+     *  The format of each task is specific to the task, and not visible to Lattice.
+     */
+    specification?: Lattice.GoogleProtobufAny | undefined;
+}

package/dist/cjs/api/types/ManualControlFrame.js

@@ -0,0 +1,3 @@
+"use strict";
+//  This file was auto-generated from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/types/ManualControlFrameEvent.d.ts

@@ -0,0 +1,3 @@
+import type * as Lattice from "../index.js";
+export interface ManualControlFrameEvent extends Lattice.ManualControlFrame {
+}

package/dist/cjs/api/types/ManualControlFrameEvent.js

@@ -0,0 +1,3 @@
+"use strict";
+//  This file was auto-generated from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/types/index.d.ts

@@ -76,6 +76,8 @@ export * from "./ListResponse.js";
 export * from "./Lla.js";
 export * from "./Location.js";
 export * from "./LocationUncertainty.js";
+export * from "./ManualControlFrame.js";
+export * from "./ManualControlFrameEvent.js";
 export * from "./MeanKeplerianElements.js";
 export * from "./Measurement.js";
 export * from "./Media.js";

package/dist/cjs/api/types/index.js

@@ -92,6 +92,8 @@ __exportStar(require("./ListResponse.js"), exports);
 __exportStar(require("./Lla.js"), exports);
 __exportStar(require("./Location.js"), exports);
 __exportStar(require("./LocationUncertainty.js"), exports);
+__exportStar(require("./ManualControlFrame.js"), exports);
+__exportStar(require("./ManualControlFrameEvent.js"), exports);
 __exportStar(require("./MeanKeplerianElements.js"), exports);
 __exportStar(require("./Measurement.js"), exports);
 __exportStar(require("./Media.js"), exports);

package/dist/cjs/core/auth/BasicAuth.d.ts

@@ -1,6 +1,6 @@
 export interface BasicAuth {
-    username: string;
-    password: string;
+    username?: string;
+    password?: string;
 }
 export declare const BasicAuth: {
     toAuthorizationHeader: (basicAuth: BasicAuth | undefined) => string | undefined;

package/dist/cjs/core/auth/BasicAuth.js

@@ -5,10 +5,16 @@ const base64_js_1 = require("../base64.js");
 const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
 exports.BasicAuth = {
     toAuthorizationHeader: (basicAuth) => {
+        var _a, _b;
         if (basicAuth == null) {
             return undefined;
         }
-        const token = (0, base64_js_1.base64Encode)(`${basicAuth.username}:${basicAuth.password}`);
+        const username = (_a = basicAuth.username) !== null && _a !== void 0 ? _a : "";
+        const password = (_b = basicAuth.password) !== null && _b !== void 0 ? _b : "";
+        if (username === "" && password === "") {
+            return undefined;
+        }
+        const token = (0, base64_js_1.base64Encode)(`${username}:${password}`);
         return `Basic ${token}`;
     },
     fromAuthorizationHeader: (header) => {

package/dist/cjs/core/fetcher/Fetcher.d.ts

@@ -38,10 +38,12 @@ export declare namespace Fetcher {
     }
     interface TimeoutError {
         reason: "timeout";
+        cause?: unknown;
     }
     interface UnknownError {
         reason: "unknown";
         errorMessage: string;
+        cause?: unknown;
     }
 }
 export declare function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>>;

package/dist/cjs/core/fetcher/Fetcher.js

@@ -261,6 +261,7 @@ function fetcherImpl(args) {
                     error: {
                         reason: "unknown",
                         errorMessage: "The user aborted a request",
+                        cause: error,
                     },
                     rawResponse: RawResponse_js_1.abortRawResponse,
                 };
@@ -278,6 +279,7 @@ function fetcherImpl(args) {
                     ok: false,
                     error: {
                         reason: "timeout",
+                        cause: error,
                     },
                     rawResponse: RawResponse_js_1.abortRawResponse,
                 };
@@ -296,6 +298,7 @@ function fetcherImpl(args) {
                     error: {
                         reason: "unknown",
                         errorMessage: error.message,
+                        cause: error,
                     },
                     rawResponse: RawResponse_js_1.unknownRawResponse,
                 };
@@ -313,6 +316,7 @@ function fetcherImpl(args) {
                 error: {
                     reason: "unknown",
                     errorMessage: (0, json_js_1.toJson)(error),
+                    cause: error,
                 },
                 rawResponse: RawResponse_js_1.unknownRawResponse,
             };

package/dist/cjs/errors/LatticeError.d.ts

@@ -3,10 +3,12 @@ export declare class LatticeError extends Error {
     readonly statusCode?: number;
     readonly body?: unknown;
     readonly rawResponse?: core.RawResponse;
-    constructor({ message, statusCode, body, rawResponse, }: {
+    readonly cause?: unknown;
+    constructor({ message, statusCode, body, rawResponse, cause, }: {
         message?: string;
         statusCode?: number;
         body?: unknown;
         rawResponse?: core.RawResponse;
+        cause?: unknown;
     });
 }

package/dist/cjs/errors/LatticeError.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LatticeError = void 0;
 const json_js_1 = require("../core/json.js");
 class LatticeError extends Error {
-    constructor({ message, statusCode, body, rawResponse, }) {
+    constructor({ message, statusCode, body, rawResponse, cause, }) {
         super(buildMessage({ message, statusCode, body }));
         Object.setPrototypeOf(this, new.target.prototype);
         if (Error.captureStackTrace) {
@@ -14,6 +14,9 @@ class LatticeError extends Error {
         this.statusCode = statusCode;
         this.body = body;
         this.rawResponse = rawResponse;
+        if (cause != null) {
+            this.cause = cause;
+        }
     }
 }
 exports.LatticeError = LatticeError;

package/dist/cjs/errors/LatticeTimeoutError.d.ts

@@ -1,3 +1,6 @@
 export declare class LatticeTimeoutError extends Error {
-    constructor(message: string);
+    readonly cause?: unknown;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
 }

package/dist/cjs/errors/LatticeTimeoutError.js

@@ -3,13 +3,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LatticeTimeoutError = void 0;
 class LatticeTimeoutError extends Error {
-    constructor(message) {
+    constructor(message, opts) {
         super(message);
         Object.setPrototypeOf(this, new.target.prototype);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         }
         this.name = this.constructor.name;
+        if ((opts === null || opts === void 0 ? void 0 : opts.cause) != null) {
+            this.cause = opts.cause;
+        }
     }
 }
 exports.LatticeTimeoutError = LatticeTimeoutError;

package/dist/cjs/errors/handleNonStatusCodeError.js

@@ -50,11 +50,14 @@ function handleNonStatusCodeError(error, rawResponse, method, path) {
                 rawResponse: rawResponse,
             });
         case "timeout":
-            throw new errors.LatticeTimeoutError(`Timeout exceeded when calling ${method} ${path}.`);
+            throw new errors.LatticeTimeoutError(`Timeout exceeded when calling ${method} ${path}.`, {
+                cause: error.cause,
+            });
         case "unknown":
             throw new errors.LatticeError({
                 message: error.errorMessage,
                 rawResponse: rawResponse,
+                cause: error.cause,
             });
         default:
             throw new errors.LatticeError({

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "4.4.1";
+export declare const SDK_VERSION = "4.6.0";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "4.4.1";
+exports.SDK_VERSION = "4.6.0";

package/dist/esm/BaseClient.mjs

@@ -6,8 +6,8 @@ export function normalizeClientOptions(options) {
     const headers = mergeHeaders({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "@anduril-industries/lattice-sdk",
-        "X-Fern-SDK-Version": "4.4.1",
-        "User-Agent": "@anduril-industries/lattice-sdk/4.4.1",
+        "X-Fern-SDK-Version": "4.6.0",
+        "User-Agent": "@anduril-industries/lattice-sdk/4.6.0",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/esm/api/resources/tasks/client/Client.d.mts

@@ -93,12 +93,11 @@ export declare class TasksClient {
      * This method initiates task cancellation based on the task's current state:
      * - If the task has not been sent to an agent, it cancels immediately and transitions the task
      *   to a terminal state (`STATUS_DONE_NOT_OK` with `ERROR_CODE_CANCELLED`).
-     * - If the task has already been sent to an agent, the cancellation request is routed to the agent with a delivery status of `DELIVERY_STATUS_PENDING_CANCEL`.
-     *   The agent is responsible for determining whether cancellation is possible and updating
-     *   the task status accordingly via the `UpdateStatus` endpoint:
-     *   - If the task can be cancelled, the agent should update the task status to `STATUS_DONE_NOT_OK`.
-     *   - If the task cannot be cancelled, the agent should attach an error to the task stating why cancellation is not possible using `UpdateStatus`
-     *     or the returned task object.
+     * - If the task has already been sent to an agent, the cancellation request is routed to the agent.
+     *   The agent is then responsible for deciding whether cancellation is possible or not:
+     *   - If the task can be cancelled, the agent must use `UpdateTaskStatus` and set the task status to `STATUS_DONE_NOT_OK`.
+     *   - If the task cannot be cancelled, the agent must use `UpdateTaskStatus` to attach a `TaskError` to the task with the error code `ERROR_CODE_REJECTED`
+     *     and a `message` explaining why the task cannot be cancelled.
      *
      * @param {Lattice.TaskCancellation} request
      * @param {TasksClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -209,4 +208,23 @@ export declare class TasksClient {
      */
     streamAsAgent(request?: Lattice.AgentStreamRequest, requestOptions?: TasksClient.RequestOptions): core.HttpResponsePromise<core.Stream<Lattice.StreamAsAgentResponse>>;
     private __streamAsAgent;
+    /**
+     * @beta This endpoint is in pre-release and may change.
+     *
+     * Establishes a server streaming connection that delivers manual control frames to agents
+     * using server-sent events (SSE).
+     *
+     * This endpoint streams manual control frames, for example, for joystick movements, for a specific task
+     * to the executing agent. The agent should open this stream before reporting `STATUS_EXECUTING`
+     * to ensure it is ready to receive control input when the operator begins sending frames.
+     *
+     * Each frame includes epoch and sequence metadata for handling concurrent control sessions
+     * and detecting stale or out-of-order frames. Heartbeat messages are sent periodically to
+     * maintain the connection.
+     *
+     * The stream terminates automatically when the task reaches a terminal state
+     * (`STATUS_DONE_OK` or `STATUS_DONE_NOT_OK`).
+     */
+    streamManualControlFrames(request: Lattice.ManualControlStreamRequest, requestOptions?: TasksClient.RequestOptions): core.HttpResponsePromise<core.Stream<Lattice.StreamManualControlFramesResponse>>;
+    private __streamManualControlFrames;
 }