@mutagent/sdk 0.4.0 → 0.4.2

package/src/models/provider-configs-list.ts

@@ -8,11 +8,6 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
-/**
- * Model name mappings
- */
-export type ProviderConfigsListModelOverrides = {};
-
 export type ProviderConfigsListSupportedModel = {
   /**
    * Model identifier
@@ -24,11 +19,6 @@ export type ProviderConfigsListSupportedModel = {
   source?: string | undefined;
 };
 
-/**
- * Additional metadata
- */
-export type ProviderConfigsListMetadata = {};
-
 /**
  * Provider config object (API key is masked)
  */
@@ -50,17 +40,9 @@ export type Config = {
    */
   apiKeyMasked: string;
   /**
-   * Organization ID if org-scoped
-   */
-  organizationId: string | null;
-  /**
-   * Workspace ID if workspace-scoped
+   * Workspace this configuration belongs to
    */
-  workspaceId: string | null;
-  /**
-   * User ID if personal
-   */
-  userId: string | null;
+  workspaceId: string;
   /**
    * Custom base URL
    */
@@ -68,19 +50,19 @@ export type Config = {
   /**
    * Model name mappings
    */
-  modelOverrides: ProviderConfigsListModelOverrides | null;
+  modelOverrides: { [k: string]: string } | null;
   /**
    * Whether the config is active
    */
   isActive: boolean;
   /**
-   * Whether this is the default for its scope
+   * Whether this is the default for its workspace
    */
   isDefault: boolean;
   /**
-   * Azure/custom wire-format family: 'openai' | 'anthropic' | 'inference'
+   * Hosted model family for gateway entries: 'openai' | 'anthropic' | 'inference'; null for direct providers
    */
-  family: string | null;
+  hostedFamily: string | null;
   /**
    * Declared models this provider serves
    */
@@ -92,7 +74,11 @@ export type Config = {
   /**
    * Additional metadata
    */
-  metadata: ProviderConfigsListMetadata | null;
+  metadata: { [k: string]: any } | null;
+  /**
+   * Non-secret per-entry credential material for this provider (region, projectId, deploymentName, etc.), keyed by the catalog wire names. Never carries the secret — that stays masked in apiKeyMasked. Exposed so an edit form can show what is actually stored: both create and update (#1388) persist non-column catalog fields here, and before this the column was write-only from the API's perspective, so an edited value vanished from the dialog on the next load even though the row held it.
+   */
+  credentialFields: { [k: string]: string } | null;
   /**
    * User ID of the creator
    */
@@ -121,22 +107,6 @@ export type ProviderConfigsList = {
   total: number;
 };
 
-/** @internal */
-export const ProviderConfigsListModelOverrides$inboundSchema: z.ZodMiniType<
-  ProviderConfigsListModelOverrides,
-  unknown
-> = z.object({});
-
-export function providerConfigsListModelOverridesFromJSON(
-  jsonString: string,
-): SafeParseResult<ProviderConfigsListModelOverrides, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ProviderConfigsListModelOverrides$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ProviderConfigsListModelOverrides' from JSON`,
-  );
-}
-
 /** @internal */
 export const ProviderConfigsListSupportedModel$inboundSchema: z.ZodMiniType<
   ProviderConfigsListSupportedModel,
@@ -159,45 +129,24 @@ export function providerConfigsListSupportedModelFromJSON(
   );
 }
 
-/** @internal */
-export const ProviderConfigsListMetadata$inboundSchema: z.ZodMiniType<
-  ProviderConfigsListMetadata,
-  unknown
-> = z.object({});
-
-export function providerConfigsListMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<ProviderConfigsListMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ProviderConfigsListMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ProviderConfigsListMetadata' from JSON`,
-  );
-}
-
 /** @internal */
 export const Config$inboundSchema: z.ZodMiniType<Config, unknown> = z.object({
   id: types.string(),
   name: types.string(),
   provider: types.string(),
   apiKeyMasked: types.string(),
-  organizationId: types.nullable(types.string()),
-  workspaceId: types.nullable(types.string()),
-  userId: types.nullable(types.string()),
+  workspaceId: types.string(),
   baseUrl: types.nullable(types.string()),
-  modelOverrides: types.nullable(
-    z.lazy(() => ProviderConfigsListModelOverrides$inboundSchema),
-  ),
+  modelOverrides: types.nullable(z.record(z.string(), types.string())),
   isActive: types.boolean(),
   isDefault: types.boolean(),
-  family: types.nullable(types.string()),
+  hostedFamily: types.nullable(types.string()),
   supportedModels: types.nullable(
     z.array(z.lazy(() => ProviderConfigsListSupportedModel$inboundSchema)),
   ),
   apiVersion: types.nullable(types.string()),
-  metadata: types.nullable(
-    z.lazy(() => ProviderConfigsListMetadata$inboundSchema),
-  ),
+  metadata: types.nullable(z.record(z.string(), z.any())),
+  credentialFields: types.nullable(z.record(z.string(), types.string())),
   createdBy: types.nullable(types.string()),
   createdAt: types.date(),
   updatedAt: types.date(),

package/src/models/schemadefaul.ts

@@ -3,14 +3,17 @@
  */
 
 import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export enum Schemadefaul {
-  Owner = "owner",
-  Admin = "admin",
-  Editor = "editor",
-  Viewer = "viewer",
+  X8664 = "x86_64",
+  Arm64 = "arm64",
 }
+export type SchemadefaulOpen = OpenEnum<typeof Schemadefaul>;
 
 /** @internal */
-export const Schemadefaul$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul> = z
-  .enum(Schemadefaul);
+export const Schemadefaul$inboundSchema: z.ZodMiniType<
+  SchemadefaulOpen,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul);

package/src/models/schemadefaul10.ts

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export enum Schemadefaul10 {
+  Owner = "owner",
+  Admin = "admin",
+  Editor = "editor",
+  Viewer = "viewer",
+}
+
+/** @internal */
+export const Schemadefaul10$outboundSchema: z.ZodMiniEnum<
+  typeof Schemadefaul10
+> = z.enum(Schemadefaul10);

package/src/models/{schemadefaul3.ts → schemadefaul12.ts}

@@ -4,12 +4,13 @@
 
 import * as z from "zod/v4-mini";
 
-export enum Schemadefaul3 {
+export enum Schemadefaul12 {
   Admin = "admin",
   Editor = "editor",
   Viewer = "viewer",
 }
 
 /** @internal */
-export const Schemadefaul3$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul3> =
-  z.enum(Schemadefaul3);
+export const Schemadefaul12$outboundSchema: z.ZodMiniEnum<
+  typeof Schemadefaul12
+> = z.enum(Schemadefaul12);

package/src/models/schemadefaul5.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+export enum Schemadefaul5 {
+  Pending = "pending",
+  Starting = "starting",
+  Running = "running",
+  Paused = "paused",
+  Stopping = "stopping",
+  Stopped = "stopped",
+  Failed = "failed",
+}
+export type Schemadefaul5Open = OpenEnum<typeof Schemadefaul5>;
+
+/** @internal */
+export const Schemadefaul5$inboundSchema: z.ZodMiniType<
+  Schemadefaul5Open,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul5);

package/src/models/schemadefaul6.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export enum Schemadefaul6 {
+  Zero = "0",
+  One = "1",
+  False = "false",
+  True = "true",
+}
+
+/** @internal */
+export const Schemadefaul6$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul6> =
+  z.enum(Schemadefaul6);

package/src/models/schemadefaul7.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+export enum Schemadefaul7 {
+  Oneshot = "oneshot",
+  Rpc = "rpc",
+}
+export type Schemadefaul7Open = OpenEnum<typeof Schemadefaul7>;
+
+/** @internal */
+export const Schemadefaul7$inboundSchema: z.ZodMiniType<
+  Schemadefaul7Open,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul7);
+/** @internal */
+export const Schemadefaul7$outboundSchema: z.ZodMiniType<
+  string,
+  Schemadefaul7Open
+> = openEnums.outboundSchema(Schemadefaul7);

package/src/models/schemadefaul8.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+export enum Schemadefaul8 {
+  Classic = "classic",
+  Prime = "prime",
+  Agent = "agent",
+}
+export type Schemadefaul8Open = OpenEnum<typeof Schemadefaul8>;
+
+/** @internal */
+export const Schemadefaul8$inboundSchema: z.ZodMiniType<
+  Schemadefaul8Open,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul8);
+/** @internal */
+export const Schemadefaul8$outboundSchema: z.ZodMiniType<
+  string,
+  Schemadefaul8Open
+> = openEnums.outboundSchema(Schemadefaul8);

package/src/models/session-id-line.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type SessionIdLine = {
+  /**
+   * The Helix session to write to — from the `start` that created it.
+   */
+  sessionId: string;
+  /**
+   * Exactly one JSON object, serialised. No trailing newline — the box appends it, so one call cannot smuggle two commands. A value that is not a single JSON object is a 400.
+   */
+  line: string;
+};
+
+/** @internal */
+export type SessionIdLine$Outbound = {
+  sessionId: string;
+  line: string;
+};
+
+/** @internal */
+export const SessionIdLine$outboundSchema: z.ZodMiniType<
+  SessionIdLine$Outbound,
+  SessionIdLine
+> = z.object({
+  sessionId: z.string(),
+  line: z.string(),
+});
+
+export function sessionIdLineToJSON(sessionIdLine: SessionIdLine): string {
+  return JSON.stringify(SessionIdLine$outboundSchema.parse(sessionIdLine));
+}

package/src/models/session-id-signal.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export enum Signal {
+  Sigint = "SIGINT",
+  Sigterm = "SIGTERM",
+}
+
+export type SessionIdSignal = {
+  /**
+   * The Helix session to signal — from the `start` that created it.
+   */
+  sessionId: string;
+  signal: Signal;
+};
+
+/** @internal */
+export const Signal$outboundSchema: z.ZodMiniEnum<typeof Signal> = z.enum(
+  Signal,
+);
+
+/** @internal */
+export type SessionIdSignal$Outbound = {
+  sessionId: string;
+  signal: string;
+};
+
+/** @internal */
+export const SessionIdSignal$outboundSchema: z.ZodMiniType<
+  SessionIdSignal$Outbound,
+  SessionIdSignal
+> = z.object({
+  sessionId: z.string(),
+  signal: Signal$outboundSchema,
+});
+
+export function sessionIdSignalToJSON(
+  sessionIdSignal: SessionIdSignal,
+): string {
+  return JSON.stringify(SessionIdSignal$outboundSchema.parse(sessionIdSignal));
+}

package/src/models/snapshot-id-definition-partial.ts

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+/**
+ * What to do when the transcript references files the receiving box does not have. A checkpoint moves the session file ONLY — the workspace does not travel — so a restore into a fresh box normally finds them missing. `warn` (default) restores and reports them in `workspaceDrift`. `refuse` fails with 409 BEFORE switching the session; use it when the box is meant to already hold the work. `skip` does not probe at all, and reports status `unchecked`.
+ */
+export enum OnWorkspaceDrift {
+  Warn = "warn",
+  Refuse = "refuse",
+  Skip = "skip",
+}
+
+export type SnapshotIdDefinitionPartial = {
+  /**
+   * Which checkpoint to restore. Defaults to the NEWEST one captured from this sandbox. Only consistency points are listed, so a default restore can never land on a mid-turn prefix.
+   */
+  snapshotId?: string | undefined;
+  /**
+   * The sandbox definition to rebuild from, when the original was not a registered preset. The stored record keeps a definition NAME, not the image/arch/network it stood for, so a sandbox spawned from an ad-hoc definition must be handed one back. Omit for preset-spawned sandboxes.
+   */
+  definition?: any | undefined;
+  /**
+   * Restore the INCREMENTAL transcript prefix when it is newer than the checkpoint row — the bytes a mid-turn kill would otherwise lose — together with the checkpoint's own workspace archive. Default false. ACCEPTED RISK: the prefix is cut at its last complete line and may end on a tool call whose result never landed; the harness answers such a call with a synthetic error result on the next turn, so the agent sees a failed call and may redo it — any side effect the original call had is not undone. Falls back to the checkpoint row, with the reason in `notRestored`, when no prefix exists, when it is not beyond the row, or when it does not extend the row's bytes (a compaction rewrote the file). `partial` on the response says which happened.
+   */
+  partial?: boolean | undefined;
+  /**
+   * What to do when the transcript references files the receiving box does not have. A checkpoint moves the session file ONLY — the workspace does not travel — so a restore into a fresh box normally finds them missing. `warn` (default) restores and reports them in `workspaceDrift`. `refuse` fails with 409 BEFORE switching the session; use it when the box is meant to already hold the work. `skip` does not probe at all, and reports status `unchecked`.
+   */
+  onWorkspaceDrift?: OnWorkspaceDrift | undefined;
+  /**
+   * Per-call environment for the RESTORED session, layered exactly as on session start: over `environment`, under the platform-owned variables. NEVER stored — not in the checkpoint, not in its manifest — so a restore that omits it does not bring back what the original session was given this way. A model key sent as `env` at session start must be sent again here.
+   */
+  env?: { [k: string]: string } | undefined;
+  /**
+   * A workspace Environment to load into the restored session. Omitted, the Environment the checkpointed session was started with — recorded by NAME, never values, in the checkpoint manifest — is re-resolved; a name given here wins. 404 before anything is torn down when the workspace has none by this name. A recorded name that no longer exists is skipped and named in `notRestored`.
+   */
+  environment?: string | undefined;
+};
+
+/** @internal */
+export const OnWorkspaceDrift$outboundSchema: z.ZodMiniEnum<
+  typeof OnWorkspaceDrift
+> = z.enum(OnWorkspaceDrift);
+
+/** @internal */
+export type SnapshotIdDefinitionPartial$Outbound = {
+  snapshotId?: string | undefined;
+  definition?: any | undefined;
+  partial?: boolean | undefined;
+  onWorkspaceDrift: string;
+  env?: { [k: string]: string } | undefined;
+  environment?: string | undefined;
+};
+
+/** @internal */
+export const SnapshotIdDefinitionPartial$outboundSchema: z.ZodMiniType<
+  SnapshotIdDefinitionPartial$Outbound,
+  SnapshotIdDefinitionPartial
+> = z.object({
+  snapshotId: z.optional(z.string()),
+  definition: z.optional(z.any()),
+  partial: z.optional(z.boolean()),
+  onWorkspaceDrift: z._default(
+    OnWorkspaceDrift$outboundSchema,
+    OnWorkspaceDrift.Warn,
+  ),
+  env: z.optional(z.record(z.string(), z.string())),
+  environment: z.optional(z.string()),
+});
+
+export function snapshotIdDefinitionPartialToJSON(
+  snapshotIdDefinitionPartial: SnapshotIdDefinitionPartial,
+): string {
+  return JSON.stringify(
+    SnapshotIdDefinitionPartial$outboundSchema.parse(
+      snapshotIdDefinitionPartial,
+    ),
+  );
+}

package/src/models/vars-secrets.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type VarsSecrets = {
+  /**
+   * Non-secret variables, name → value. Stored readable; returned only as fingerprints.
+   */
+  vars?: { [k: string]: any } | undefined;
+  /**
+   * Secret values, name → value. WRITE-ONLY: encrypted at rest with the provider-credential key, never returned by any route.
+   */
+  secrets?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export type VarsSecrets$Outbound = {
+  vars?: { [k: string]: any } | undefined;
+  secrets?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const VarsSecrets$outboundSchema: z.ZodMiniType<
+  VarsSecrets$Outbound,
+  VarsSecrets
+> = z.object({
+  vars: z.optional(z.record(z.string(), z.any())),
+  secrets: z.optional(z.record(z.string(), z.any())),
+});
+
+export function varsSecretsToJSON(varsSecrets: VarsSecrets): string {
+  return JSON.stringify(VarsSecrets$outboundSchema.parse(varsSecrets));
+}

package/src/models/workspace-model-listing.ts

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type Model = {
+  /**
+   * Model identifier, as the provider addresses it
+   */
+  id: string;
+  /**
+   * Human-readable name
+   */
+  displayName: string;
+  /**
+   * Whether this workspace exposes the model. An empty allow-list enables everything.
+   */
+  enabled: boolean;
+  /**
+   * Role list: exec, eval, opt
+   */
+  roles: Array<string>;
+  /**
+   * False when the provider hides which model an identifier serves (an Azure deployment name), so admission was by shape alone.
+   */
+  modelVerified: boolean;
+};
+
+/**
+ * 'live' — listed from the provider just now; 'stored' — the persisted allow-list
+ */
+export enum Source {
+  Live = "live",
+  Stored = "stored",
+}
+/**
+ * 'live' — listed from the provider just now; 'stored' — the persisted allow-list
+ */
+export type SourceOpen = OpenEnum<typeof Source>;
+
+/**
+ * A provider configuration's models, with this workspace's enablement applied
+ */
+export type WorkspaceModelListing = {
+  models: Array<Model>;
+  /**
+   * 'live' — listed from the provider just now; 'stored' — the persisted allow-list
+   */
+  source: SourceOpen;
+  /**
+   * True when the live listing failed and the stored allow-list is being shown
+   */
+  degraded: boolean;
+  /**
+   * Why the listing degraded, or a provider-stated caveat. Null when neither.
+   */
+  message: string | null;
+};
+
+/** @internal */
+export const Model$inboundSchema: z.ZodMiniType<Model, unknown> = z.object({
+  id: types.string(),
+  displayName: types.string(),
+  enabled: types.boolean(),
+  roles: z.array(types.string()),
+  modelVerified: types.boolean(),
+});
+
+export function modelFromJSON(
+  jsonString: string,
+): SafeParseResult<Model, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Model$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Model' from JSON`,
+  );
+}
+
+/** @internal */
+export const Source$inboundSchema: z.ZodMiniType<SourceOpen, unknown> =
+  openEnums.inboundSchema(Source);
+
+/** @internal */
+export const WorkspaceModelListing$inboundSchema: z.ZodMiniType<
+  WorkspaceModelListing,
+  unknown
+> = z.object({
+  models: z.array(z.lazy(() => Model$inboundSchema)),
+  source: z._default(Source$inboundSchema, Source.Live),
+  degraded: types.boolean(),
+  message: types.nullable(types.string()),
+});
+
+export function workspaceModelListingFromJSON(
+  jsonString: string,
+): SafeParseResult<WorkspaceModelListing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorkspaceModelListing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorkspaceModelListing' from JSON`,
+  );
+}