ql-agent-sdk 1.4.0 → 1.4.1

package/dist/index.d.cts

@@ -750,6 +750,433 @@ interface FileUploadOptions {
      */
     onProgress?: (percent: number) => void;
 }
+/** Approval lifecycle states (GET /api/v1/approvals `status` filter accepts these). */
+declare const APPROVAL_STATUSES: readonly ["pending", "approved", "rejected", "expired", "consumed", "invalidated", "cancelled"];
+type ApprovalStatus = (typeof APPROVAL_STATUSES)[number];
+/** A target entity an action is bound to (e.g. a document or collection). */
+interface TargetEntity {
+    type: string;
+    id: string;
+}
+/** Policy evaluation summary attached to an approval request. */
+interface ApprovalPolicyResult {
+    /** "full_autonomy" | "silent_approval" | "hard_block" (null when not evaluated). */
+    level: string | null;
+    rulePackId: string | null;
+    ruleId: string | null;
+    severity: string | null;
+    reason: string;
+}
+/** List-safe approval view — no payload or evidence (use `approvals.get` for the full record). */
+interface ApprovalSummary {
+    approvalId: string;
+    /** One of APPROVAL_STATUSES. */
+    status: string;
+    action: string;
+    targetEntity: TargetEntity | null;
+    actorType: string;
+    agentId: string | null;
+    subagentId: string | null;
+    executionId: string | null;
+    approvalLevel: string;
+    policyResult: ApprovalPolicyResult;
+    idempotencyKey: string;
+    reviewUntil: string | Date | null;
+    expiresAt: string | Date;
+    decidedBy: string | null;
+    decidedAt: string | Date | null;
+    createdAt: string | Date;
+}
+/** Full approval record including the bound payload (credentials stripped server-side) and evidence. */
+interface ApprovalDetail extends ApprovalSummary {
+    payload: Record<string, unknown>;
+    payloadHash: string | null;
+    decisionNote: string | null;
+    approvalEvidence: Record<string, unknown> | null;
+    executionResult: Record<string, unknown> | null;
+    executedAt: string | Date | null;
+    consumedAt: string | Date | null;
+    ledgerSeqRequested: number | null;
+}
+/** Params for `approvals.list`. */
+interface ListApprovalsParams {
+    /** Filter by one or more statuses (sent comma-joined). */
+    status?: ApprovalStatus[];
+    /** Page size (default 50, max 200). */
+    limit?: number;
+    /** Only approvals created before this ISO date. */
+    beforeCreatedAt?: string | Date;
+}
+/** Result of `approvals.list`. */
+interface ApprovalsListResult {
+    items: ApprovalSummary[];
+    total: number;
+}
+/** Input for `approvals.decide`. Public API keys carry no user identity, so the deciding workspace member must be named. */
+interface DecideApprovalInput {
+    decision: "approve" | "reject";
+    /** User id of a current member of this workspace. */
+    decidedBy: string;
+    /** Optional note (truncated to 2000 chars server-side). */
+    note?: string;
+    /** Optional structured evidence attached to the decision. */
+    evidence?: Record<string, unknown>;
+}
+/** Result of `approvals.decide`. */
+interface DecideApprovalResult {
+    approvalId: string;
+    status: string | null;
+}
+/** Result of `approvals.execute`. The approval is consumed exactly once on the success path. */
+interface ExecuteApprovalResult {
+    /** False when the executor ran and failed — the outcome is recorded, NOT retried. */
+    ok: boolean;
+    approvalId: string;
+    action: string | null;
+    /** Always "consumed" on HTTP 200 (the approval was atomically consumed). */
+    status: "consumed";
+    result: Record<string, unknown> | null;
+    error?: string;
+}
+/** Match conditions for a policy rule (all present fields must match the action descriptor). */
+interface PolicyRuleConditions {
+    action?: string;
+    httpMethod?: string[];
+    collection?: string[];
+}
+/** A single policy rule as returned by `policies.get`. */
+interface PolicyRule {
+    ruleId: string;
+    rulePackId: string;
+    version: number;
+    description: string;
+    conditions: PolicyRuleConditions;
+    severity: "info" | "low" | "medium" | "high" | "critical";
+    approvalLevel: "full_autonomy" | "silent_approval" | "hard_block";
+    correctiveAction: string | null;
+}
+/** A policy rule pack (active packs are evaluated; roadmap packs are not). */
+interface PolicyPack {
+    id: string;
+    name: string;
+    version: number;
+    description: string;
+    active: boolean;
+    rules: PolicyRule[];
+}
+/** A client-specified rule pack documented as a roadmap requirement (definitions to be supplied by the client). */
+interface RoadmapPolicyPack {
+    id: string;
+    note: string;
+}
+/** Result of `policies.get`. */
+interface PoliciesResult {
+    packs: PolicyPack[];
+    activePackIds: string[];
+    roadmapPacks: RoadmapPolicyPack[];
+    stats: {
+        total: number;
+        active: number;
+        roadmap: number;
+        rulesTotal: number;
+    };
+}
+/** One event in the workspace's append-only, hash-chained audit ledger. */
+interface LedgerEvent {
+    seq: number;
+    type: string;
+    actorType: string;
+    actorId: string;
+    agentId: string | null;
+    subagentId: string | null;
+    executionId: string | null;
+    entityRefs: TargetEntity[];
+    payload: Record<string, unknown>;
+    prevHash: string;
+    eventHash: string;
+    timestampMs: number;
+    createdAt: string | Date;
+}
+/** Params for `events.list` (newest first; `beforeSeq` pages backwards). */
+interface ListEventsParams {
+    /** Page size (default 50, max 200). */
+    limit?: number;
+    /** Only events with seq < this value. */
+    beforeSeq?: number;
+    /** Only these event types (sent comma-joined). */
+    types?: string[];
+}
+/** Result of `events.list`. */
+interface EventsPage {
+    items: LedgerEvent[];
+    hasMore: boolean;
+    /** Pass as `beforeSeq` to fetch the next (older) page when `hasMore`. */
+    nextBeforeSeq?: number;
+    total?: number;
+}
+/** Params for `events.verify`. */
+interface VerifyChainParams {
+    /** Verify only events with seq <= this value (windowed verification). */
+    afterSeq?: number;
+}
+/** Result of `events.verify` — recomputes every hash and checks each prevHash link. */
+interface VerifyChainResult {
+    valid: boolean;
+    checkedCount: number;
+    firstBadSeq?: number;
+    reason?: string;
+}
+/** Result of `events.retention`. No automatic deletion runs (fail-closed audit posture). */
+interface RetentionReport {
+    retentionDays: number;
+    oldestEventAt?: string | Date;
+    eventsInsideRetentionWindow: number;
+    eventsOutsideRetentionWindow: number;
+    autoDeletionEnabled: false;
+    note: string;
+}
+/** Agent tool names a subagent may be granted. */
+type AgentToolName = "fetch_collections" | "fetch_schema" | "query_collection" | "create_document" | "update_document" | "delete_document" | "http_request" | "dispatch_agent";
+/** Capability scopes a subagent may hold (audited, enforced at the tool layer). */
+type SubagentPermission = "db.read" | "db.write" | "http.outbound";
+/** A declared input of a subagent dispatch. */
+interface SubagentInputSpec {
+    name: string;
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required: boolean;
+    description: string;
+}
+/** Output contract of a subagent (minimal JSON-schema-style object). */
+interface SubagentOutputSchema {
+    type: "object";
+    properties: Record<string, {
+        type: string;
+        description?: string;
+    }>;
+    required?: string[];
+}
+/** Bounded execution constraints for one dispatch. */
+interface SubagentExecutionConstraints {
+    /** Max model tool rounds for one dispatch (bounded loop). */
+    maxRounds: number;
+    /** Per-round model call timeout. */
+    roundTimeoutMs: number;
+    /** Wall-clock budget for the whole dispatch (soft, best-effort race). */
+    totalTimeoutMs: number;
+}
+/** A versioned specialist subagent definition owned by exactly one domain agent. */
+interface SubagentDefinition {
+    /** Stable id: "<ownerAgentId>.<kebab-name>" — never rename. */
+    id: string;
+    name: string;
+    description: string;
+    /** Owning top-level agent id (one of the eight domain agents). */
+    ownerAgentId: string;
+    responsibilities: string[];
+    inputs: SubagentInputSpec[];
+    outputSchema: SubagentOutputSchema;
+    /** Skill ids this specialist may use. */
+    skills: string[];
+    permittedTools: AgentToolName[];
+    permissions: SubagentPermission[];
+    constraints: string[];
+    executionConstraints: SubagentExecutionConstraints;
+    /** Dispatch depth at which this specialist may be activated (1 = direct child of its owner). */
+    activationDepth: number;
+    enabled: boolean;
+    /** Present when the specialist applies only to certain verticals. */
+    applicabilityNote?: string;
+    version: number;
+}
+/** Honest registry stats over a set of subagent definitions. */
+interface SubagentStats {
+    total: number;
+    enabled: number;
+    disabled: number;
+    /** Ids of specialists granted the http_request tool. */
+    withHttp: string[];
+    byAgent: Record<string, {
+        total: number;
+        enabled: number;
+    }>;
+}
+/** Result of `subagents.list`. */
+interface SubagentsListResult {
+    items: SubagentDefinition[];
+    stats: SubagentStats;
+}
+/** "read" → gated as skill_read (read-only); "write" → skill_run (protected). */
+type SkillExecutionClass = "read" | "write";
+/** Permission scopes a calling agent/subagent must hold. */
+type SkillPermission = "db.read" | "db.write" | "http.outbound";
+/** A property in a skill input/output contract. */
+interface SkillProperty {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string;
+    /** When true, null is accepted for this property (strict otherwise). */
+    nullable?: boolean;
+    /** Numbers only. */
+    minimum?: number;
+    maximum?: number;
+}
+/** Minimal JSON-schema-style object contract (strict: unknown keys are rejected). */
+interface SkillIOContract {
+    type: "object";
+    properties: Record<string, SkillProperty>;
+    required?: string[];
+}
+/** Public skill definition — the implementation function is never exposed. */
+interface SkillDefinition {
+    /** Stable id: "<domainAgentId>.<kebab-name>" — never rename. */
+    id: string;
+    name: string;
+    description: string;
+    /** Bumped on any behavior change. */
+    version: number;
+    enabled: boolean;
+    executionClass: SkillExecutionClass;
+    /** Owning/permitted caller domains (agent template ids). User actors are always permitted. */
+    domains: string[];
+    /** Permissions the calling agent/subagent must hold (empty = none required). */
+    requiredPermissions: SkillPermission[];
+    inputSchema: SkillIOContract;
+    outputSchema: SkillIOContract;
+    /** Wall-clock execution limit (bounded by design). */
+    timeoutMs: number;
+    /** Max serialized input size in bytes. */
+    maxInputBytes: number;
+    /** True → the run fails closed if its required audit event cannot be recorded. */
+    auditRequired: boolean;
+    /** All skill failures surface as structured {ok:false, errorCode, error} results. */
+    errorBehavior: "structured";
+}
+/** Honest registry stats over all skills. */
+interface SkillStats {
+    total: number;
+    readOnly: number;
+    write: number;
+    enabled: number;
+    /** Count keyed by the domain prefix of the skill id (before the first dot). */
+    byDomain: Record<string, number>;
+}
+/** Result of `skills.list`. */
+interface SkillsListResult {
+    items: SkillDefinition[];
+    stats: SkillStats;
+}
+/** Policy evaluation attached to a gated skill run. */
+interface SkillPolicyEvaluation {
+    level: "full_autonomy" | "silent_approval" | "hard_block";
+    rulePackId?: string | null;
+    ruleId?: string | null;
+    severity?: "info" | "low" | "medium" | "high" | "critical" | null;
+    reason: string;
+    correctiveAction?: string;
+    /** True when the hard_block is a fail-closed default (no valid rule matched). */
+    failClosed?: boolean;
+    skippedMalformedRules?: number;
+}
+/** Input for `skills.run`. Public API keys carry no user identity, so the acting workspace member must be named. */
+interface SkillRunInput {
+    skillId: string;
+    input: Record<string, unknown>;
+    /** User id of a current member of this workspace. */
+    actorUserId: string;
+    /** Approval dedupe key (prevents duplicate approval requests — NOT result caching). */
+    idempotencyKey?: string;
+}
+/** Structured outcome of one skill run through the validation → authorization → policy → audit → execution pipeline. */
+interface SkillRunResult {
+    ok: boolean;
+    status: "completed" | "blocked" | "approval_required" | "failed";
+    skillId: string;
+    errorCode?: string;
+    error?: string;
+    output?: unknown;
+    /** Present when the run is policy-gated as silent_approval — drive it via approvals.decide + approvals.execute. */
+    approvalId?: string;
+    evaluation?: SkillPolicyEvaluation;
+}
+/** Execution lifecycle states (GET /api/v1/executions `status` filter accepts these). */
+declare const EXECUTION_STATUSES: readonly ["running", "completed", "failed", "cancelled", "timeout"];
+type ExecutionStatus = (typeof EXECUTION_STATUSES)[number];
+/** One tool call recorded in an execution trace. */
+interface ExecutionToolCall {
+    seq: number;
+    toolName: string;
+    ok: boolean;
+    durationMs?: number;
+    error?: string;
+    /** Approval request id when the tool call was policy-gated. */
+    approvalId?: string;
+    /** Ledger seq of the related audit event, if any. */
+    ledgerSeq?: number;
+}
+/** Token usage recorded for an execution (when reported by the model layer). */
+interface ExecutionTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    model?: string;
+}
+/** List-safe execution view — no embedded tool-call log (use `executions.get` for the full trace). */
+interface ExecutionSummary {
+    executionId: string;
+    parentExecutionId: string | null;
+    agentType: "agent" | "subagent";
+    agentId: string;
+    subagentId: string | null;
+    status: ExecutionStatus;
+    startedAt: string | Date;
+    finishedAt: string | Date | null;
+    durationMs: number | null;
+    costUsd: number | null;
+    createdAt: string | Date;
+}
+/** Params for `executions.list`. */
+interface ListExecutionsParams {
+    /** Filter by owning domain agent slug. */
+    agentId?: string;
+    /** Filter by one or more statuses (sent comma-joined). */
+    status?: ExecutionStatus[];
+    /** Page size (default 50, max 200). */
+    limit?: number;
+    /** Only executions created before this ISO date. */
+    beforeCreatedAt?: string | Date;
+}
+/** Result of `executions.list`. */
+interface ExecutionsListResult {
+    items: ExecutionSummary[];
+    total: number;
+}
+/** Full execution trace including tool calls, approvals, and ledger references. */
+interface ExecutionDetail {
+    execution: {
+        executionId: string;
+        parentExecutionId: string | null;
+        agentType: "agent" | "subagent";
+        agentId: string;
+        subagentId: string | null;
+        userId: string | null;
+        status: ExecutionStatus;
+        inputMeta: Record<string, unknown> | null;
+        outputMeta: Record<string, unknown> | null;
+        toolCalls: ExecutionToolCall[];
+        tokenUsage: ExecutionTokenUsage | null;
+        costUsd: number | null;
+        durationMs: number | null;
+        error: string | null;
+        /** ApprovalRequest ids involved in this execution. */
+        approvalRefs: string[];
+        /** Ledger seqs of audit events emitted for this execution. */
+        ledgerEventIds: number[];
+        startedAt: string | Date;
+        finishedAt: string | Date | null;
+        createdAt: string | Date;
+    };
+    /** Direct child executions (subagent dispatches from this execution). */
+    children: ExecutionSummary[];
+}
 
 declare function isTerminalTaskStatus(status: string): boolean;
 /**
@@ -917,6 +1344,66 @@ declare class FilesApi {
     /** POST /api/v1/files — upload a media file (multipart field "file"). */
     upload(file: Blob, opts?: FileUploadOptions): Promise<UploadedFile>;
 }
+/** Approvals namespace (policy approval lifecycle). */
+declare class ApprovalsApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/approvals — list policy approval requests (list-safe views, no payload). */
+    list(params?: ListApprovalsParams): Promise<ApprovalsListResult>;
+    /** GET /api/v1/approvals/:id — full approval record incl. bound payload + evidence. */
+    get(approvalId: string): Promise<ApprovalDetail>;
+    /** POST /api/v1/approvals/:id/decide — record an authorized workspace member's decision. */
+    decide(approvalId: string, input: DecideApprovalInput): Promise<DecideApprovalResult>;
+    /** POST /api/v1/approvals/:id/execute — execute the bound action of an approved approval, exactly once. */
+    execute(approvalId: string): Promise<ExecuteApprovalResult>;
+}
+/** Policies namespace (rule-pack registry). */
+declare class PoliciesApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/policies — active rule packs with their rules + documented roadmap packs. */
+    get(): Promise<PoliciesResult>;
+}
+/** Events namespace (hash-chained audit ledger). */
+declare class EventsApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/events — paginated ledger read, newest first (`beforeSeq` pages backwards). */
+    list(params?: ListEventsParams): Promise<EventsPage>;
+    /** GET /api/v1/events/verify — recompute every hash and check each prevHash link (audit retrieval). */
+    verify(params?: VerifyChainParams): Promise<VerifyChainResult>;
+    /** GET /api/v1/events/retention — retention report (no automatic deletion runs). */
+    retention(): Promise<RetentionReport>;
+}
+/** Subagents namespace (specialist subagent registry). */
+declare class SubagentsApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/subagents — specialist definitions + honest stats (optionally filtered by owning agent). */
+    list(agentId?: string): Promise<SubagentsListResult>;
+    /** GET /api/v1/subagents/:id — one specialist definition. */
+    get(subagentId: string): Promise<SubagentDefinition>;
+}
+/** Skills namespace (shared skill registry + execution). */
+declare class SkillsApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/skills — skill definitions (no implementation functions) + honest stats. */
+    list(domain?: string): Promise<SkillsListResult>;
+    /** GET /api/v1/skills/:id — one skill definition. */
+    get(skillId: string): Promise<SkillDefinition>;
+    /** POST /api/v1/skills/run — run a skill through the full validation → authorization → policy → audit → execution pipeline. */
+    run(input: SkillRunInput): Promise<SkillRunResult>;
+}
+/** Executions namespace (agent/subagent execution traces). */
+declare class ExecutionsApi {
+    private readonly t;
+    constructor(t: Transport);
+    /** GET /api/v1/executions — execution history (list-safe views, no tool-call log). */
+    list(params?: ListExecutionsParams): Promise<ExecutionsListResult>;
+    /** GET /api/v1/executions/:id — full execution trace incl. tool calls + direct children. */
+    get(executionId: string): Promise<ExecutionDetail>;
+}
 /**
  * The public client. Example:
  *   const ql = new QLClient({ apiKey: process.env.QL_API_KEY });
@@ -931,6 +1418,12 @@ declare class QLClient {
     readonly videos: VideosApi;
     readonly audio: AudioApi;
     readonly files: FilesApi;
+    readonly approvals: ApprovalsApi;
+    readonly policies: PoliciesApi;
+    readonly events: EventsApi;
+    readonly subagents: SubagentsApi;
+    readonly skills: SkillsApi;
+    readonly executions: ExecutionsApi;
     private readonly transport;
     private readonly base;
     constructor(opts: QLClientOptions);
@@ -974,4 +1467,4 @@ declare class QLError extends Error {
     get isNetworkError(): boolean;
 }
 
-export { API_ERROR_CODES, type AgentDetail, type AgentFeedToolCall, type AgentListResult, type AgentMessageItem, type AgentMessageKind, type AgentMessageOutputFormat, type AgentMessagesPage, type AgentMessagesParams, type AgentSummary, AgentsApi, type ApiErrorCode, AudioApi, type CapParamKind, type CapabilitiesResult, type CapabilityInfo, type CapabilityParam, type CapabilityResult, type CapabilityTemplate, type ChatFile, type ChatInput, type ChatMessage, type ChatResult, type ChatStreamEvent, type CreateKeyInput, type CreateKeyResult, DEFAULT_BASE_URL, type DeleteKeyResult, type DiscardedKey, type FileUploadOptions, FilesApi, type GeneratedImage, type HistoryPage, type HistoryParams, type ImageGenerateInput, type ImageGenerateResult, type ImageModelInfo, type ImageModelsResult, type ImagePricingEntry, type ImageReferenceInput, type ImageTier, type ImageUsage, ImagesApi, type MessageItem, type MintedKey, QLClient, type QLClientOptions, QLError, type QLErrorContext, type RunCapabilityInput, type RunCapabilityResult, type StreamOptions, type Task, type TaskCreateInput, type TaskCreated, TaskHandle, type TaskPriority, type TaskStatus, TasksApi, type TtsInput, type TtsResult, type UploadedFile, type VideoGenerateInput, type VideoModelInfo, type VideoModelsResult, type VideoPricingEntry, type VideoTask, type VideoTaskCreated, VideoTaskHandle, type VideoTaskStatus, type VideoTier, type VideoWaitOptions, VideosApi, type VoiceInfo, type VoicesResult, type WaitOptions, type WorkflowRun, type WorkflowRunInput, type WorkflowRunStart, type WorkflowRunStatus, WorkflowsApi, type Workspace, WorkspaceApi, isTerminalTaskStatus };
+export { API_ERROR_CODES, APPROVAL_STATUSES, type AgentDetail, type AgentFeedToolCall, type AgentListResult, type AgentMessageItem, type AgentMessageKind, type AgentMessageOutputFormat, type AgentMessagesPage, type AgentMessagesParams, type AgentSummary, type AgentToolName, AgentsApi, type ApiErrorCode, type ApprovalDetail, type ApprovalPolicyResult, type ApprovalStatus, type ApprovalSummary, ApprovalsApi, type ApprovalsListResult, AudioApi, type CapParamKind, type CapabilitiesResult, type CapabilityInfo, type CapabilityParam, type CapabilityResult, type CapabilityTemplate, type ChatFile, type ChatInput, type ChatMessage, type ChatResult, type ChatStreamEvent, type CreateKeyInput, type CreateKeyResult, DEFAULT_BASE_URL, type DecideApprovalInput, type DecideApprovalResult, type DeleteKeyResult, type DiscardedKey, EXECUTION_STATUSES, EventsApi, type EventsPage, type ExecuteApprovalResult, type ExecutionDetail, type ExecutionStatus, type ExecutionSummary, type ExecutionTokenUsage, type ExecutionToolCall, ExecutionsApi, type ExecutionsListResult, type FileUploadOptions, FilesApi, type GeneratedImage, type HistoryPage, type HistoryParams, type ImageGenerateInput, type ImageGenerateResult, type ImageModelInfo, type ImageModelsResult, type ImagePricingEntry, type ImageReferenceInput, type ImageTier, type ImageUsage, ImagesApi, type LedgerEvent, type ListApprovalsParams, type ListEventsParams, type ListExecutionsParams, type MessageItem, type MintedKey, PoliciesApi, type PoliciesResult, type PolicyPack, type PolicyRule, type PolicyRuleConditions, QLClient, type QLClientOptions, QLError, type QLErrorContext, type RetentionReport, type RoadmapPolicyPack, type RunCapabilityInput, type RunCapabilityResult, type SkillDefinition, type SkillExecutionClass, type SkillIOContract, type SkillPermission, type SkillPolicyEvaluation, type SkillProperty, type SkillRunInput, type SkillRunResult, type SkillStats, SkillsApi, type SkillsListResult, type StreamOptions, type SubagentDefinition, type SubagentExecutionConstraints, type SubagentInputSpec, type SubagentOutputSchema, type SubagentPermission, type SubagentStats, SubagentsApi, type SubagentsListResult, type TargetEntity, type Task, type TaskCreateInput, type TaskCreated, TaskHandle, type TaskPriority, type TaskStatus, TasksApi, type TtsInput, type TtsResult, type UploadedFile, type VerifyChainParams, type VerifyChainResult, type VideoGenerateInput, type VideoModelInfo, type VideoModelsResult, type VideoPricingEntry, type VideoTask, type VideoTaskCreated, VideoTaskHandle, type VideoTaskStatus, type VideoTier, type VideoWaitOptions, VideosApi, type VoiceInfo, type VoicesResult, type WaitOptions, type WorkflowRun, type WorkflowRunInput, type WorkflowRunStart, type WorkflowRunStatus, WorkflowsApi, type Workspace, WorkspaceApi, isTerminalTaskStatus };