@alienplatform/manager-api 1.3.5 → 1.4.0

package/src/funcs/deploymentGroupsCreateDeploymentGroup.ts

@@ -24,6 +24,14 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * Every handler in this file runs `auth::require_auth(&state, &headers)`
+ * and then threads `&subject` into the `DeploymentStore` calls — see the
+ * trait doc on [`DeploymentStore`] for the convention.
+ *
+ * @remarks
+ * `POST /v1/deployment-groups` — Inbound: workspace bearer.
+ */
 export function deploymentGroupsCreateDeploymentGroup(
   client: AlienManagerCore,
   request: models.CreateDeploymentGroupRequest,

package/src/funcs/deploymentsCreateDeployment.ts

@@ -24,6 +24,17 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * Every handler in this file runs `auth::require_auth(&state, &headers)`
+ * and then threads `&subject` into the `DeploymentStore` calls. Embedders
+ * that proxy to an upstream API can use the subject's `bearer_token` for
+ * passthrough; single-tenant impls ignore it. See the trait doc on
+ * [`DeploymentStore`] for the full convention.
+ *
+ * @remarks
+ * `POST /v1/deployments` — Inbound: workspace / project / dg bearer (or
+ * authenticated user). Deployment-scoped tokens cannot create deployments.
+ */
 export function deploymentsCreateDeployment(
   client: AlienManagerCore,
   request: models.CreateDeploymentRequest,

package/src/funcs/deploymentsDeleteDeployment.ts

@@ -90,6 +90,7 @@ async function $do(
   const path = pathToFunc("/v1/deployments/{id}")(pathParams);
 
   const query = encodeFormQuery({
+    "deleteScope": payload.deleteScope,
     "force": payload.force,
   });
 

package/src/funcs/stackImportStackImport.ts

@@ -0,0 +1,165 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { AlienManagerCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { AlienManagerError } from "../models/errors/alienmanagererror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * `POST /v1/stack/import` — Inbound: deployment-group bearer.
+ *
+ * @remarks
+ * The body's `deploymentGroupToken` field is informational (mirrored back
+ * for log correlation) — actual authentication is the standard `Authorization
+ * Bearer` header processed by [`auth::require_auth`]. The handler tolerates
+ * the body field being either the raw token or empty; it never reads
+ * credentials from the body to make the secret path uniform with every
+ * other endpoint.
+ */
+export function stackImportStackImport(
+  client: AlienManagerCore,
+  request: models.StackImportRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    models.StackImportResponse,
+    | AlienManagerError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: AlienManagerCore,
+  request: models.StackImportRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      models.StackImportResponse,
+      | AlienManagerError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => models.StackImportRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/v1/stack/import")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "stack_import",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "401", "403", "404", "409", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const [result] = await M.match<
+    models.StackImportResponse,
+    | AlienManagerError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json([200, 201], models.StackImportResponse$inboundSchema),
+    M.fail([400, 401, 403, 404, 409, "4XX"]),
+    M.fail("5XX"),
+  )(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/syncAcquire.ts

@@ -24,6 +24,11 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * `POST /v1/sync/acquire` — Inbound: workspace / dg / deployment bearer.
+ * `caller: &Subject` is threaded into `DeploymentStore::acquire` so
+ * embedders can authorize against the inbound caller's scope.
+ */
 export function syncAcquire(
   client: AlienManagerCore,
   request: models.AcquireRequest,

package/src/funcs/syncAgentSync.ts

@@ -24,6 +24,11 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * `POST /v1/sync` — Inbound: deployment bearer. The agent-driven sync
+ * path; `caller: &Subject` is threaded into the store so embedders see
+ * the agent's own scope.
+ */
 export function syncAgentSync(
   client: AlienManagerCore,
   request: models.AgentSyncRequest,

package/src/funcs/syncInitialize.ts

@@ -24,6 +24,13 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * `POST /v1/initialize` — Inbound: deployment-group bearer (typical),
+ * or workspace bearer for self-hosted operator workflows. New deployments
+ * are created via `DeploymentStore::create_deployment(caller, …)` so
+ * embedders that proxy to an upstream API write the row in the dg's
+ * workspace, not the manager's.
+ */
 export function syncInitialize(
   client: AlienManagerCore,
   request: models.InitializeRequest,

package/src/funcs/syncReconcile.ts

@@ -24,6 +24,10 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * `POST /v1/sync/reconcile` — Inbound: workspace / dg / deployment
+ * bearer. `caller: &Subject` is threaded into `DeploymentStore::reconcile`.
+ */
 export function syncReconcile(
   client: AlienManagerCore,
   request: models.ReconcileRequest,

package/src/funcs/syncRelease.ts

@@ -25,6 +25,10 @@ import * as models from "../models/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+/**
+ * `POST /v1/sync/release` — Inbound: workspace / dg / deployment bearer.
+ * `caller: &Subject` is threaded into `DeploymentStore::release`.
+ */
 export function syncRelease(
   client: AlienManagerCore,
   request: models.ReleaseRequest,

package/src/lib/config.ts

@@ -58,8 +58,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "1.1.0",
+  sdkVersion: "1.2.46",
   genVersion: "2.788.15",
   userAgent:
-    "speakeasy-sdk/typescript 1.1.0 2.788.15 1.0.0 @alienplatform/manager-api",
+    "speakeasy-sdk/typescript 1.2.46 2.788.15 1.0.0 @alienplatform/manager-api",
 } as const;

package/src/models/acquirerequest.ts

@@ -3,12 +3,12 @@
  */
 
 import * as z from "zod/v4";
-import { Platform, Platform$outboundSchema } from "./platform.js";
+import { PlatformEnum, PlatformEnum$outboundSchema } from "./platformenum.js";
 
 export type AcquireRequest = {
   deploymentIds?: Array<string> | null | undefined;
   limit?: number | undefined;
-  platforms?: Array<Platform> | null | undefined;
+  platforms?: Array<PlatformEnum> | null | undefined;
   session: string;
   statuses?: Array<string> | null | undefined;
 };
@@ -29,7 +29,7 @@ export const AcquireRequest$outboundSchema: z.ZodType<
 > = z.object({
   deploymentIds: z.nullable(z.array(z.string())).optional(),
   limit: z.int().optional(),
-  platforms: z.nullable(z.array(Platform$outboundSchema)).optional(),
+  platforms: z.nullable(z.array(PlatformEnum$outboundSchema)).optional(),
   session: z.string(),
   statuses: z.nullable(z.array(z.string())).optional(),
 });

package/src/models/agentsyncresponse.ts

@@ -9,12 +9,21 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type AgentSyncResponse = {
   /**
-   * Public URL for the commands API. Cloud-deployed functions use this
+   * Public URL for the commands API. Cloud-deployed workers use this
    *
    * @remarks
    * to poll for pending commands instead of the agent's local sync URL.
    */
   commandsUrl?: string | null | undefined;
+  /**
+   * Authoritative deployment state from the manager.
+   *
+   * @remarks
+   *
+   * Returned when a pull deployment attaches with an empty local state while
+   * the manager already has imported or previously reconciled state.
+   */
+  currentState?: any | undefined;
   target?: any | undefined;
 };
 
@@ -24,6 +33,7 @@ export const AgentSyncResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   commandsUrl: z.nullable(z.string()).optional(),
+  currentState: z.any().optional(),
   target: z.any().optional(),
 });
 

package/src/models/alienerror.ts

@@ -0,0 +1,117 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Canonical error container that provides a structured way to represent errors
+ *
+ * @remarks
+ * with rich metadata including error codes, human-readable messages, context,
+ * and chaining capabilities for error propagation.
+ *
+ * This struct is designed to be both machine-readable and user-friendly,
+ * supporting serialization for API responses and detailed error reporting
+ * in distributed systems.
+ */
+export type AlienError = {
+  /**
+   * A unique identifier for the type of error.
+   *
+   * @remarks
+   *
+   * This should be a short, machine-readable string that can be used
+   * by clients to programmatically handle different error types.
+   * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
+   */
+  code: string;
+  /**
+   * Additional diagnostic information about the error context.
+   *
+   * @remarks
+   *
+   * This optional field can contain structured data providing more details
+   * about the error, such as validation errors, request parameters that
+   * caused the issue, or other relevant context information.
+   */
+  context?: any | undefined;
+  /**
+   * Optional human-facing remediation hint.
+   */
+  hint?: string | null | undefined;
+  /**
+   * HTTP status code for this error.
+   *
+   * @remarks
+   *
+   * Used when converting the error to an HTTP response. If None, falls back to
+   * the error type's default status code or 500.
+   */
+  httpStatusCode?: number | null | undefined;
+  /**
+   * Indicates if this is an internal error that should not be exposed to users.
+   *
+   * @remarks
+   *
+   * When `true`, this error contains sensitive information or implementation
+   * details that should not be shown to end-users. Such errors should be
+   * logged for debugging but replaced with generic error messages in responses.
+   */
+  internal: boolean;
+  /**
+   * Human-readable error message.
+   *
+   * @remarks
+   *
+   * This message should be clear and actionable for developers or end-users,
+   * providing context about what went wrong and potentially how to fix it.
+   */
+  message: string;
+  /**
+   * Indicates whether the operation that caused the error should be retried.
+   *
+   * @remarks
+   *
+   * When `true`, the error is transient and the operation might succeed
+   * if attempted again. When `false`, retrying the same operation is
+   * unlikely to succeed without changes.
+   */
+  retryable: boolean;
+  /**
+   * The underlying error that caused this error, creating an error chain.
+   *
+   * @remarks
+   *
+   * This allows for proper error propagation and debugging by maintaining
+   * the full context of how an error occurred through multiple layers
+   * of an application.
+   */
+  source?: any | undefined;
+};
+
+/** @internal */
+export const AlienError$inboundSchema: z.ZodType<AlienError, unknown> = z
+  .object({
+    code: z.string(),
+    context: z.any().optional(),
+    hint: z.nullable(z.string()).optional(),
+    httpStatusCode: z.nullable(z.int()).optional(),
+    internal: z.boolean(),
+    message: z.string(),
+    retryable: z.boolean().default(false),
+    source: z.any().optional(),
+  });
+
+export function alienErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<AlienError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AlienError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AlienError' from JSON`,
+  );
+}