@datalayer/core 1.1.60 → 1.2.10

package/lib/models/Credits.js

@@ -9,3 +9,25 @@
  * TODO what is a good LOW_CREDITS bar? - A better way would be to set it from a server settings or a cloud config.
  */
 export const LOW_CREDITS = 3;
+/**
+ * The credits an account can still spend.
+ *
+ * `credits` means one of two things depending on whether a quota is set: what
+ * is left, or what has been consumed against the quota. IAM omits `quota`
+ * entirely for an account without one, so an absent quota is read the same as
+ * an explicit `null` — testing only against `null` let `undefined` take the
+ * quota branch and produced `NaN`, which then travelled silently into every
+ * reader of this number.
+ *
+ * Outstanding reservations are already committed, so they are subtracted:
+ * what is returned is what a new reservation may still claim.
+ */
+export const availableCredits = (credits, reservations = []) => {
+    const quota = credits.quota;
+    const balance = typeof quota === 'number' ? quota - credits.credits : credits.credits;
+    if (!Number.isFinite(balance)) {
+        return 0;
+    }
+    const reserved = reservations.reduce((consumed, reservation) => consumed + (Number.isFinite(reservation.credits) ? reservation.credits : 0), 0);
+    return Math.max(0, balance - reserved);
+};

package/lib/models/CreditsDTO.d.ts

@@ -21,7 +21,7 @@ export interface CreditReservation {
     resource: string;
     /** Last update timestamp */
     last_update: string;
-    /** Burning rate (credits per hour) for this reservation */
+    /** Burning rate (credits per second) for this reservation */
     burning_rate: number;
     /** Start date of the reservation */
     start_date: string;
@@ -81,7 +81,8 @@ export declare class CreditsDTO {
      */
     get netAvailable(): number;
     /**
-     * Get runtime reservations (reservations that start with 'runtime-').
+     * Get runtime reservations: the ones held for a runtime, which a
+     * reservation names by the runtime's uid.
      */
     get runtimeReservations(): CreditReservation[];
     /**
@@ -91,7 +92,7 @@ export declare class CreditsDTO {
     /**
      * Calculate maximum runtime in minutes based on environment burning rate.
      *
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns Maximum runtime in minutes
      */
     calculateMaxRuntimeMinutes(burningRate: number): number;
@@ -99,7 +100,7 @@ export declare class CreditsDTO {
      * Calculate credits needed for runtime duration.
      *
      * @param minutes - Runtime duration in minutes
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns Credits needed
      */
     calculateCreditsFromMinutes(minutes: number, burningRate: number): number;
@@ -107,7 +108,7 @@ export declare class CreditsDTO {
      * Check if user has enough credits for runtime.
      *
      * @param minutes - Runtime duration in minutes
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns True if user has enough credits
      */
     hasEnoughCreditsForRuntime(minutes: number, burningRate: number): boolean;

package/lib/models/CreditsDTO.js

@@ -7,6 +7,7 @@
  *
  * @module models/CreditsDTO
  */
+import { isSandboxUid } from '../api/contents/sandboxUid.js';
 import { validateJSON } from '../api/utils/validation.js';
 /**
  * Credits model representing user's available credits and usage.
@@ -67,10 +68,11 @@ export class CreditsDTO {
         return Math.max(0, this.available - this.totalReserved);
     }
     /**
-     * Get runtime reservations (reservations that start with 'runtime-').
+     * Get runtime reservations: the ones held for a runtime, which a
+     * reservation names by the runtime's uid.
      */
     get runtimeReservations() {
-        return this._reservations.filter(r => r.id.startsWith('runtime-'));
+        return this._reservations.filter(r => isSandboxUid(r.resource) || isSandboxUid(r.id));
     }
     /**
      * Check if there are any active runtime reservations.
@@ -81,7 +83,7 @@ export class CreditsDTO {
     /**
      * Calculate maximum runtime in minutes based on environment burning rate.
      *
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns Maximum runtime in minutes
      */
     calculateMaxRuntimeMinutes(burningRate) {
@@ -94,7 +96,7 @@ export class CreditsDTO {
      * Calculate credits needed for runtime duration.
      *
      * @param minutes - Runtime duration in minutes
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns Credits needed
      */
     calculateCreditsFromMinutes(minutes, burningRate) {
@@ -105,7 +107,7 @@ export class CreditsDTO {
      * Check if user has enough credits for runtime.
      *
      * @param minutes - Runtime duration in minutes
-     * @param burningRate - Credits consumed per hour
+     * @param burningRate - Credits consumed per second
      * @returns True if user has enough credits
      */
     hasEnoughCreditsForRuntime(minutes, burningRate) {

package/lib/models/McpAuditEvent.d.ts

@@ -0,0 +1,52 @@
+/**
+ * An audit row of the Jupyter MCP Server: one call or one decision, written
+ * by the gateway for every request, append-only in `mcp-audit`.
+ *
+ * Audit answers *who did what, and was it allowed*. It is not telemetry: a
+ * row carries the trace id so one trace joins both trails, and never an
+ * argument in clear — arguments are hashed and redacted with the Contents
+ * rules before they reach the row.
+ *
+ * @module models/McpAuditEvent
+ */
+export type McpAuditDecision = 'allowed' | 'refused';
+export type McpAuditOutcome = 'ok' | 'error' | 'is_error';
+export interface McpClientInfo {
+    name?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export interface McpAuditEvent {
+    uid: string;
+    at: string;
+    orgUid?: string | null;
+    teamUid?: string | null;
+    userUid: string;
+    clientId?: string | null;
+    agentUid?: string | null;
+    /** The delegation chain (RFC 8693 `act`), outermost first. */
+    act?: string[];
+    /** The JSON-RPC method, or the REST route for a gateway API call. */
+    method: string;
+    tool?: string | null;
+    itemUid?: string | null;
+    sourceUid?: string | null;
+    cellId?: string | null;
+    argumentsHash?: string | null;
+    redactedArguments?: Record<string, unknown> | null;
+    decision: McpAuditDecision;
+    /** Names the rule and, once policy has layers, the layer that decided. */
+    refusalReason?: string | null;
+    outcome?: McpAuditOutcome | null;
+    durationMs?: number | null;
+    taskId?: string | null;
+    traceId?: string | null;
+    replica?: string | null;
+    protocolVersion?: string | null;
+    clientInfo?: McpClientInfo | null;
+}
+export interface McpAuditEventList {
+    items: McpAuditEvent[];
+    nextCursor?: string | null;
+}
+export type McpAuditExportFormat = 'jsonl' | 'csv';

package/lib/models/McpAuditEvent.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/models/McpBinding.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A binding of the Jupyter MCP Server: a handle an agent holds on a
+ * notebook (`nb_…`), a toolset (`ts_…`) or a sandbox (`sb_…`).
+ *
+ * The sandbox binding *is* the session: one per (user, client) unless a
+ * client holds several on purpose. A notebook binding names the sandbox its
+ * cells execute on. Bindings live in `mcp-gateway`, expire with the item or
+ * the reservation they follow, and are refreshed on use.
+ *
+ * @module models/McpBinding
+ */
+export type McpBindingKind = 'notebook' | 'toolset' | 'sandbox';
+/** What the gateway does when the sandbox behind a binding is gone. */
+export type McpBindingOnLost = 'fail' | 'relaunch';
+/** Where a sandbox binding is; `lost` is what `SANDBOX_LOST` reports. */
+export type McpBindingState = 'active' | 'lost' | 'closed' | 'expired';
+export interface McpBinding {
+    /** The handle: `nb_…`, `ts_…` or `sb_…`. */
+    uid: string;
+    kind: McpBindingKind;
+    userUid: string;
+    clientId?: string | null;
+    agentUid?: string | null;
+    orgUid?: string | null;
+    alias?: string | null;
+    /** The Spacer notebook, for a `notebook` binding. */
+    itemUid?: string | null;
+    /** The Contents source and session, for a `toolset` binding. */
+    sourceUid?: string | null;
+    sessionUid?: string | null;
+    /** The runtime, for a `sandbox` binding. */
+    sandboxUid?: string | null;
+    /**
+     * What Runtimes and the Operator know the sandbox by, which is **not** the
+     * handle. Sharing is addressed by this name; sending the handle instead is
+     * a `403` that reads as "you are not the owner".
+     */
+    runtimeName?: string | null;
+    sandboxProvider?: string | null;
+    /** What the runtime reported it can do. */
+    capabilities?: string[];
+    onLost?: McpBindingOnLost;
+    /** The gateway replica whose worker holds the connection. */
+    workerReplica?: string | null;
+    /** The owner's uid when the sandbox is shared with the caller through its ACL. */
+    sharedFrom?: string | null;
+    /** For a notebook binding: the sandbox its cells execute on. */
+    sandboxBindingUid?: string | null;
+    state?: McpBindingState;
+    createdAt: string;
+    lastUsedAt?: string | null;
+    expiresAt?: string | null;
+}
+export interface McpBindingList {
+    items: McpBinding[];
+    nextCursor?: string | null;
+}

package/lib/models/McpBinding.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/models/McpPolicy.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The MCP policy: what an agent *may do*.
+ *
+ * Policy is layered and each layer only narrows: platform ∩ organization ∩
+ * team for an organization-scope token, platform ∩ personal for a
+ * personal-scope one. The organization's and the person's layers are IAM
+ * settings; the gateway answers the **effective** policy for a token with,
+ * per rule, which layer decided — what the Policies page renders as
+ * "Datalayer default", "required by your organization" or "you asked".
+ *
+ * Until milestone 3 adds the layers, `GET /api/mcp/v1/policy` answers the
+ * platform defaults from `tool_policy.py` and the token's scopes.
+ *
+ * @module models/McpPolicy
+ */
+export type McpPolicyLayer = 'platform' | 'organization' | 'team' | 'personal';
+/** The Contents approval vocabulary. */
+export type McpApprovalPolicy = 'explicit' | 'auto-allowlisted' | 'never';
+export type McpPolicyScope = 'personal' | 'organization';
+/** One rule of the effective policy, and the layer that decided it. */
+export interface McpPolicyRule {
+    /** The rule's name in the organization policy vocabulary, e.g. `tool_denylist`. */
+    name: string;
+    value: unknown;
+    decidedBy: McpPolicyLayer;
+    /** Why, when the gateway has a sentence for it. */
+    reason?: string | null;
+}
+/** What one tool needs, and what happens before it runs. */
+export interface McpToolRule {
+    tool: string;
+    scope: string;
+    access?: 'read' | 'write' | 'execute';
+    approval?: McpApprovalPolicy;
+    allowed: boolean;
+    decidedBy: McpPolicyLayer;
+}
+/** The effective policy for one token, redacted to what its holder may see. */
+export interface McpEffectivePolicy {
+    scope: McpPolicyScope;
+    orgUid?: string | null;
+    teamUid?: string | null;
+    /** The agent the policy was evaluated for, when previewing as one. */
+    clientId?: string | null;
+    /** The scopes the token carries; the ceiling over every tool rule. */
+    scopes: string[];
+    rules: McpPolicyRule[];
+    tools: McpToolRule[];
+    evaluatedAt?: string;
+}
+/**
+ * The organization (or team) MCP policy as IAM keeps it, versioned and
+ * audited. Every field is optional: an absent rule narrows nothing.
+ */
+export interface McpOrganizationPolicy {
+    version?: number;
+    /** CIMD URLs, client ids or software ids; fails closed. */
+    allowedClients?: string[];
+    requireDpop?: boolean;
+    requireOrgSso?: boolean;
+    maxScopes?: string[];
+    toolAllowlist?: string[];
+    toolDenylist?: string[];
+    /** Per tool, or per annotation (`destructiveHint`, `readOnlyHint`). */
+    approvalPolicy?: Record<string, McpApprovalPolicy>;
+    allowedEnvironments?: string[];
+    allowedProviders?: string[];
+    maxGpu?: number;
+    maxReservationMinutes?: number;
+    creditsPerDay?: number;
+    callsPerMinute?: number;
+    sessionMaxHours?: number;
+    updatedAt?: string;
+    updatedBy?: string;
+}
+/** A person's rules for the agents acting for them outside any organization. */
+export type McpPersonalPolicy = Pick<McpOrganizationPolicy, 'version' | 'approvalPolicy' | 'creditsPerDay' | 'toolDenylist' | 'allowedEnvironments' | 'sessionMaxHours' | 'updatedAt'>;

package/lib/models/McpPolicy.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/models/McpTask.d.ts

@@ -0,0 +1,94 @@
+/**
+ * A task of the Jupyter MCP Server: one tool call that outlives the request
+ * that started it.
+ *
+ * The `uid` is the MCP `taskId`. A task is submitted by an agent, runs in
+ * the sandbox its session is bound to, and is reachable by anyone allowed to
+ * see the notebook it touched — from another device, forty minutes later.
+ * The gateway keeps the portable projection in `mcp-tasks`; the workflow
+ * engine owns claims and recovery, which is why there are no lease fields.
+ *
+ * Snake case on the wire, camel case here, exactly as Contents does.
+ *
+ * @module models/McpTask
+ */
+/** Where a task has got to; the MCP task status vocabulary. */
+export type McpTaskStatus = 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+/** The engine a task's workflow runs on. */
+export type McpWorkflowEngine = 'temporal' | 'dbos';
+/** A tool result small enough to travel with the task. */
+export interface McpCallToolResult {
+    content?: Array<Record<string, unknown>>;
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+    [key: string]: unknown;
+}
+/** One output of a task, in order; large outputs are references. */
+export interface McpTaskOutput {
+    index: number;
+    outputType: string;
+    mimeType?: string | null;
+    /** Inline text under the size limit. */
+    text?: string | null;
+    /** An object reference for anything larger. */
+    reference?: string | null;
+}
+export interface McpTask {
+    uid: string;
+    status: McpTaskStatus;
+    statusMessage?: string | null;
+    tool: string;
+    notebookUid?: string | null;
+    cellId?: string | null;
+    sandboxUid?: string | null;
+    /** A Contents operation, when the task wraps one. */
+    operationUid?: string | null;
+    /** An attachment, when the task follows its lifecycle without an operation. */
+    attachmentUid?: string | null;
+    /** A Contents `mcp_approval` or an ai-agents tool approval. */
+    approvalUid?: string | null;
+    /** The session the task executes in; never empty for an execution task. */
+    sandboxBindingUid?: string | null;
+    initiatingUser: string;
+    initiatingClient?: string | null;
+    orgUid?: string | null;
+    createdAt: string;
+    lastUpdatedAt: string;
+    ttlMs?: number | null;
+    pollIntervalMs?: number | null;
+    /** The `CallToolResult` for small results; a resource URI otherwise. */
+    result?: McpCallToolResult | string | null;
+    error?: string | null;
+    traceId?: string | null;
+    workflowEngine?: McpWorkflowEngine | null;
+    /** Always the task uid, so a retried start cannot create a second execution. */
+    workflowId?: string | null;
+    /** The Temporal run id; empty for DBOS. */
+    workflowRunId?: string | null;
+    queue?: string | null;
+    sandboxProvider?: string | null;
+    workerReplica?: string | null;
+    outputs?: McpTaskOutput[];
+}
+export interface McpTaskList {
+    items: McpTask[];
+    nextCursor?: string | null;
+}
+/** What `POST /tasks/{uid}/input` carries: the REST face of `tasks/update`. */
+export interface McpTaskInput {
+    input: Record<string, unknown>;
+}
+/** A `notifications/tasks` payload, as the SSE stream and the socket carry it. */
+export interface McpTaskEvent {
+    /** `status`, `output`, `input_required`, `completed`, `failed`, `cancelled`. */
+    event: string;
+    taskId: string;
+    status?: McpTaskStatus;
+    statusMessage?: string | null;
+    output?: McpTaskOutput;
+    task?: McpTask;
+    at?: string;
+}
+/** The statuses from which nothing more happens. */
+export declare const MCP_TERMINAL_TASK_STATUSES: ReadonlySet<McpTaskStatus>;
+export declare const isMcpTaskTerminal: (status: McpTaskStatus) => boolean;

package/lib/models/McpTask.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The statuses from which nothing more happens. */
+export const MCP_TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+export const isMcpTaskTerminal = (status) => MCP_TERMINAL_TASK_STATUSES.has(status);

package/lib/models/Organization.d.ts

@@ -1,6 +1,19 @@
 import { ITeam } from './Team';
 import { ISchool } from './School';
 import { IOrganizationMember } from './OrganizationMember';
+/**
+ * The agreements (AWS calls each a licence) of an AWS Marketplace organization.
+ *
+ * Read from `aws_licenses_s`, the JSON string IAM keeps on the organization
+ * document: a list of `{arn, status, agreement_id, offer_id, first_seen,
+ * deprovisioned_at, ended_at}`. Anything that does not parse is dropped
+ * rather than thrown on, and every ARN of `licenseArns` the JSON does not
+ * name is appended as an `active` agreement — which is what an organization
+ * written before the field existed holds, and what is left when the JSON is
+ * invalid. The same reading the services make, so the page and the API never
+ * disagree about which agreements exist.
+ */
+export declare function asAwsMarketplaceLicenses(raw: unknown, licenseArns?: string[]): IAwsMarketplaceLicense[];
 /**
  * Convert the raw user object to {@link IOrganization}.
  *
@@ -9,6 +22,55 @@ import { IOrganizationMember } from './OrganizationMember';
  */
 export declare function asOrganization(org: any): IOrganization;
 export type IAnyOrganization = IOrganization | ISchool;
+/**
+ * What an organization created from an AWS Marketplace subscription carries.
+ *
+ * The subscription status is the one AWS last told us, or `pending` until it
+ * does. `pending` no longer locks the organization — usage is postpaid and
+ * metered by AWS regardless; only `failed` and `cancelled` lock it read-only,
+ * and the API says so on every refused mutation. A subscription may carry
+ * several concurrent agreements, each identified by a licence ARN.
+ */
+/**
+ * Where an agreement stands: `active` while the buyer is entitled under it,
+ * `ending` from the moment AWS says it is deprovisioned — the hour AWS gives
+ * to report its last usage — and `ended` once that hour has passed.
+ */
+export type IAwsMarketplaceLicenseStatus = 'active' | 'ending' | 'ended';
+/** One agreement of an AWS Marketplace subscription; AWS calls it a licence. */
+export type IAwsMarketplaceLicense = {
+    /** The licence ARN, which is how AWS names the agreement. */
+    arn: string;
+    status: IAwsMarketplaceLicenseStatus;
+    agreementId?: string;
+    offerId?: string;
+    /** When the platform first saw the agreement. */
+    firstSeen?: Date;
+    /** When AWS said the agreement was deprovisioned. */
+    deprovisionedAt?: Date;
+    /** When the hour to report its last usage ran out. */
+    endedAt?: Date;
+};
+export type IOrganizationAwsMarketplace = {
+    accountId: string;
+    productCode: string;
+    /** The AWS customer identifier, when the resolve or a notification gave one. */
+    customerIdentifier?: string;
+    /** The AWS offer this subscription was bought under, when known. */
+    offerId?: string;
+    /** Every agreement (licence ARN) seen for this subscription. */
+    licenseArns: string[];
+    /**
+     * Every agreement with its status and dates. An organization may hold
+     * several at once, and stays usable while at least one is `active`.
+     */
+    licenses: IAwsMarketplaceLicense[];
+    subscriptionStatus: 'pending' | 'active' | 'failed' | 'cancelling' | 'cancelled' | string;
+    freeTrial: boolean;
+    dimensions: string[];
+    values: string[];
+    lastMeteredAt?: Date;
+};
 export type IBaseOrganization = {
     id: string;
     handle: string;
@@ -19,6 +81,13 @@ export type IBaseOrganization = {
     avatarIcon?: string;
     banner?: string;
     public: boolean;
+    /**
+     * Where the organization came from, as a URN — an AWS Marketplace
+     * subscription, say. Absent for a native organization.
+     */
+    origin?: string;
+    /** The subscription, for an organization whose origin is the AWS Marketplace. */
+    awsMarketplace?: IOrganizationAwsMarketplace;
     creationDate: Date;
     members: IOrganizationMember[];
     setMembers: (members: IOrganizationMember[]) => void;

package/lib/models/Organization.js

@@ -4,6 +4,78 @@
  */
 import { asArray } from '../utils/index.js';
 import { asUser } from './User.js';
+const AWS_LICENSE_STATUSES = [
+    'active',
+    'ending',
+    'ended',
+];
+function asOptionalDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    const date = value instanceof Date ? value : new Date(String(value));
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function asOptionalString(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+/**
+ * The agreements (AWS calls each a licence) of an AWS Marketplace organization.
+ *
+ * Read from `aws_licenses_s`, the JSON string IAM keeps on the organization
+ * document: a list of `{arn, status, agreement_id, offer_id, first_seen,
+ * deprovisioned_at, ended_at}`. Anything that does not parse is dropped
+ * rather than thrown on, and every ARN of `licenseArns` the JSON does not
+ * name is appended as an `active` agreement — which is what an organization
+ * written before the field existed holds, and what is left when the JSON is
+ * invalid. The same reading the services make, so the page and the API never
+ * disagree about which agreements exist.
+ */
+export function asAwsMarketplaceLicenses(raw, licenseArns = []) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        try {
+            parsed = raw.trim() ? JSON.parse(raw) : [];
+        }
+        catch {
+            parsed = [];
+        }
+    }
+    const licenses = [];
+    const known = new Set();
+    for (const entry of Array.isArray(parsed) ? parsed : []) {
+        if (!entry || typeof entry !== 'object') {
+            continue;
+        }
+        const record = entry;
+        const arn = String(record.arn ?? '').trim();
+        if (!arn || known.has(arn)) {
+            continue;
+        }
+        known.add(arn);
+        const status = String(record.status ?? '')
+            .trim()
+            .toLowerCase();
+        licenses.push({
+            arn,
+            status: AWS_LICENSE_STATUSES.includes(status) ? status : 'active',
+            agreementId: asOptionalString(record.agreement_id ?? record.agreementId),
+            offerId: asOptionalString(record.offer_id ?? record.offerId),
+            firstSeen: asOptionalDate(record.first_seen ?? record.firstSeen),
+            deprovisionedAt: asOptionalDate(record.deprovisioned_at ?? record.deprovisionedAt),
+            endedAt: asOptionalDate(record.ended_at ?? record.endedAt),
+        });
+    }
+    for (const value of licenseArns) {
+        const arn = String(value ?? '').trim();
+        if (arn && !known.has(arn)) {
+            known.add(arn);
+            licenses.push({ arn, status: 'active' });
+        }
+    }
+    return licenses;
+}
 /**
  * Convert the raw user object to {@link IOrganization}.
  *
@@ -28,6 +100,30 @@ export function asOrganization(org) {
         avatarIcon: org.avatar_icon_s ?? org.avatarIcon,
         banner: org.banner_s ?? org.banner,
         public: org.public_b,
+        // Where the organization came from — a URN such as
+        // `urn:dla:iam:ext::aws:<account>/<product>` — or nothing for a native one.
+        origin: org.origin_s ?? org.origin ?? undefined,
+        awsMarketplace: org.aws_account_id_s
+            ? {
+                accountId: org.aws_account_id_s,
+                productCode: org.aws_product_code_s,
+                customerIdentifier: org.aws_customer_identifier_s || undefined,
+                offerId: org.aws_offer_identifier_s || undefined,
+                // Every agreement (licence ARN) seen for this subscription. A
+                // subscription may carry several concurrent agreements.
+                licenseArns: asArray(org.aws_license_arns_ss ?? []),
+                // The same agreements with what is known of each — status,
+                // agreement id, dates — read defensively from the JSON IAM keeps.
+                licenses: asAwsMarketplaceLicenses(org.aws_licenses_s, asArray(org.aws_license_arns_ss ?? [])),
+                subscriptionStatus: org.aws_subscription_status_s ?? 'pending',
+                freeTrial: Boolean(org.aws_free_trial_b),
+                dimensions: asArray(org.aws_dimensions_ss ?? []),
+                values: asArray(org.aws_values_ss ?? []),
+                lastMeteredAt: org.aws_last_metered_ts_dt
+                    ? new Date(org.aws_last_metered_ts_dt)
+                    : undefined,
+            }
+            : undefined,
         members,
         teams: [],
         creationDate: new Date(org.creation_ts_dt),

package/lib/models/Secret.d.ts

@@ -140,12 +140,11 @@ export declare class SecretDTO {
      */
     constructor(data: SecretData, client: DatalayerCoreClient);
     private _checkDeleted;
-    private _decodeValue;
     get uid(): string;
     get variant(): ISecretVariant;
     get name(): string;
     get description(): string;
-    /** Returns decoded (plain text) secret value */
+    /** The value as its owner wrote it (PLAN_ENVS.md E3-05). */
     get value(): string;
     /**
      * Update this secret.