@myapihq/sdk 1.2.9 → 1.3.0

package/dist/client.js

@@ -64,16 +64,16 @@ async function request(method, url, apiKey, body, extraHeaders) {
         const err = result?.error;
         const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
         const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-        const body = typeof err === 'object' ? err : undefined;
-        throw new MyApiError(code, response.status, detail, body);
+        const errBody = typeof err === 'object' ? err : undefined;
+        throw new MyApiError(code, response.status, detail, errBody);
     }
     const apiResponse = result;
     if (!apiResponse.success) {
         const err = apiResponse.error;
         const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
         const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-        const body = typeof err === 'object' ? err : undefined;
-        throw new MyApiError(code, response.status, detail, body);
+        const errBody = typeof err === 'object' ? err : undefined;
+        throw new MyApiError(code, response.status, detail, errBody);
     }
     return apiResponse.data;
 }

package/dist/config.d.ts

@@ -5,6 +5,8 @@ export declare const FUNCTION_BASE: string;
 export declare const PAYMENTS_BASE: string;
 export declare const CONTAINER_BASE: string;
 export declare const GIT_BASE: string;
+export declare const QUEUE_BASE: string;
+export declare const TASK_BASE: string;
 export declare const IMAGE_BASE: string;
 export declare const WEBHOOK_BASE: string;
 export declare const WORKFLOW_BASE: string;

package/dist/config.js

@@ -8,7 +8,7 @@
 // local dev — `source scripts/local-env.sh` still points everything at
 // localhost:8080 regardless of the prod default.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CRM_BASE = exports.DATABASE_BASE = exports.LLM_BASE = exports.AUDIENCE_BASE = exports.COMPANY_BASE = exports.PEOPLE_BASE = exports.PIXEL_BASE = exports.URL_BASE = exports.STORAGE_BASE = exports.EMAIL_BASE = exports.WORKFLOW_BASE = exports.WEBHOOK_BASE = exports.IMAGE_BASE = exports.GIT_BASE = exports.CONTAINER_BASE = exports.PAYMENTS_BASE = exports.FUNCTION_BASE = exports.FUNNEL_BASE = exports.DOMAIN_BASE = exports.HQ_BASE = void 0;
+exports.CRM_BASE = exports.DATABASE_BASE = exports.LLM_BASE = exports.AUDIENCE_BASE = exports.COMPANY_BASE = exports.PEOPLE_BASE = exports.PIXEL_BASE = exports.URL_BASE = exports.STORAGE_BASE = exports.EMAIL_BASE = exports.WORKFLOW_BASE = exports.WEBHOOK_BASE = exports.IMAGE_BASE = exports.TASK_BASE = exports.QUEUE_BASE = exports.GIT_BASE = exports.CONTAINER_BASE = exports.PAYMENTS_BASE = exports.FUNCTION_BASE = exports.FUNNEL_BASE = exports.DOMAIN_BASE = exports.HQ_BASE = void 0;
 const GATEWAY = 'https://api.myapihq.com';
 exports.HQ_BASE = process.env.MYAPI_HQ_URL ?? process.env.MYAPI_API_BASE ?? GATEWAY;
 exports.DOMAIN_BASE = process.env.MYAPI_DOMAIN_URL ?? 'https://api.mydomainapi.com';
@@ -19,6 +19,8 @@ exports.FUNCTION_BASE = process.env.MYAPI_FUNCTION_URL ?? GATEWAY;
 exports.PAYMENTS_BASE = process.env.MYAPI_PAYMENTS_URL ?? GATEWAY;
 exports.CONTAINER_BASE = process.env.MYAPI_CONTAINER_URL ?? GATEWAY;
 exports.GIT_BASE = process.env.MYAPI_GIT_URL ?? GATEWAY;
+exports.QUEUE_BASE = process.env.MYAPI_QUEUE_URL ?? GATEWAY;
+exports.TASK_BASE = process.env.MYAPI_TASK_URL ?? GATEWAY;
 exports.IMAGE_BASE = process.env.MYAPI_IMAGE_URL ?? 'https://api.myimageapi.com';
 exports.WEBHOOK_BASE = process.env.MYAPI_WEBHOOK_URL ?? 'https://api.mywebhookapi.com';
 exports.WORKFLOW_BASE = process.env.MYAPI_WORKFLOW_URL ?? 'https://api.myworkflowapi.com';

package/dist/email.d.ts

@@ -118,6 +118,11 @@ export declare function activateSending(apiKey: string, address: string): Promis
     sending_enabled: boolean;
     emails_quota_remaining: number;
 }>;
+export declare function setForwarding(apiKey: string, address: string, forwardTo: string): Promise<{
+    address: string;
+    forward_to: string;
+}>;
+export declare function deleteForwarding(apiKey: string, address: string): Promise<void>;
 export declare function sendEmail(apiKey: string, payload: {
     from: string;
     to: string[];

package/dist/email.js

@@ -7,6 +7,8 @@ exports.getVerifyJob = getVerifyJob;
 exports.createMailbox = createMailbox;
 exports.listMailboxes = listMailboxes;
 exports.activateSending = activateSending;
+exports.setForwarding = setForwarding;
+exports.deleteForwarding = deleteForwarding;
 exports.sendEmail = sendEmail;
 exports.getEmailStatus = getEmailStatus;
 exports.getSentEmails = getSentEmails;
@@ -43,6 +45,8 @@ exports.EXPOSES = [
     // Mailbox / sending activation
     'POST /email/mailboxes/create',
     'GET /email/mailboxes',
+    'PUT /email/mailboxes/{address}/forwarding',
+    'DELETE /email/mailboxes/{address}/forwarding',
     'POST /email/sending/activate',
     // Send + read
     'POST /email/send',
@@ -115,6 +119,16 @@ async function listMailboxes(apiKey, options) {
 async function activateSending(apiKey, address) {
     return (0, client_1.request)('POST', `${config_1.EMAIL_BASE}/email/sending/activate`, apiKey, { address });
 }
+// setForwarding redirects a copy of every incoming message to an external
+// address (server-side; the original is kept in the mailbox). `forwardTo`
+// must be a valid address and cannot equal the mailbox itself.
+async function setForwarding(apiKey, address, forwardTo) {
+    return (0, client_1.request)('PUT', `${config_1.EMAIL_BASE}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey, { forward_to: forwardTo });
+}
+// deleteForwarding stops forwarding for a mailbox.
+async function deleteForwarding(apiKey, address) {
+    return (0, client_1.request)('DELETE', `${config_1.EMAIL_BASE}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey);
+}
 // ── Sending and reading (account-scoped) ─────────────────────────────────────
 async function sendEmail(apiKey, payload) {
     return (0, client_1.request)('POST', `${config_1.EMAIL_BASE}/email/send`, apiKey, payload);

package/dist/index.d.ts

@@ -20,3 +20,5 @@ export * as fn from './function';
 export * as payments from './payments';
 export * as container from './container';
 export * as git from './git';
+export * as queue from './queue';
+export * as task from './task';

package/dist/index.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.git = exports.container = exports.payments = exports.fn = exports.crm = exports.database = exports.llm = exports.audience = exports.company = exports.people = exports.url = exports.workflow = exports.webhook = exports.storage = exports.pixel = exports.image = exports.funnel = exports.email = exports.domain = exports.hq = void 0;
+exports.task = exports.queue = exports.git = exports.container = exports.payments = exports.fn = exports.crm = exports.database = exports.llm = exports.audience = exports.company = exports.people = exports.url = exports.workflow = exports.webhook = exports.storage = exports.pixel = exports.image = exports.funnel = exports.email = exports.domain = exports.hq = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./client"), exports);
 // Note: config constants (STORAGE_BASE etc.) are NOT re-exported from the
@@ -65,3 +65,5 @@ exports.fn = __importStar(require("./function"));
 exports.payments = __importStar(require("./payments"));
 exports.container = __importStar(require("./container"));
 exports.git = __importStar(require("./git"));
+exports.queue = __importStar(require("./queue"));
+exports.task = __importStar(require("./task"));

package/dist/queue.d.ts

@@ -0,0 +1,49 @@
+import type { Exposes } from './exposes';
+export declare const EXPOSES: Exposes;
+export interface Queue {
+    id: string;
+    org_id: string;
+    name: string;
+    consumer_url: string;
+    max_attempts: number;
+    max_concurrency: number;
+    created_at: string;
+}
+export type JobStatus = 'pending' | 'blocked' | 'running' | 'succeeded' | 'dead';
+export interface Job {
+    id: string;
+    queue_id: string;
+    org_id: string;
+    payload: unknown;
+    status: JobStatus;
+    attempt: number;
+    max_attempts: number;
+    not_before: string;
+    depends_on: string[];
+    dedup_key?: string;
+    last_error?: string;
+    started_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateQueueOptions {
+    name: string;
+    consumerUrl: string;
+    maxAttempts?: number;
+    maxConcurrency?: number;
+}
+export interface EnqueueOptions {
+    payload?: unknown;
+    dedupKey?: string;
+    delaySeconds?: number;
+    dependsOn?: string[];
+}
+export declare function createQueue(apiKey: string, orgId: string, opts: CreateQueueOptions): Promise<Queue>;
+export declare function listQueues(apiKey: string, orgId: string): Promise<Queue[]>;
+export declare function getQueue(apiKey: string, orgId: string, name: string): Promise<Queue>;
+export declare function enqueueJob(apiKey: string, orgId: string, name: string, opts?: EnqueueOptions): Promise<Job>;
+export declare function listJobs(apiKey: string, orgId: string, name: string, opts?: {
+    status?: string;
+    limit?: number;
+}): Promise<Job[]>;
+export declare function getJob(apiKey: string, orgId: string, jobId: string): Promise<Job>;

package/dist/queue.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPOSES = void 0;
+exports.createQueue = createQueue;
+exports.listQueues = listQueues;
+exports.getQueue = getQueue;
+exports.enqueueJob = enqueueJob;
+exports.listJobs = listJobs;
+exports.getJob = getJob;
+const client_1 = require("./client");
+const config_1 = require("./config");
+// Backend: my-queue-api per myapi-hq/internal/routes/queue/. A durable
+// HTTP-consumer job queue — each named queue POSTs its jobs to a configured
+// consumer_url, with retry/backoff to max_attempts, a concurrency cap, and a
+// dependency DAG (a job with unsucceeded depends_on starts blocked).
+exports.EXPOSES = [
+    'POST /queue/orgs/{org_id}/queues',
+    'GET /queue/orgs/{org_id}/queues',
+    'GET /queue/orgs/{org_id}/queues/{name}',
+    'POST /queue/orgs/{org_id}/queues/{name}/jobs',
+    'GET /queue/orgs/{org_id}/queues/{name}/jobs',
+    'GET /queue/orgs/{org_id}/jobs/{id}',
+];
+function queuesBase(orgId) {
+    return `${config_1.QUEUE_BASE}/queue/orgs/${encodeURIComponent(orgId)}/queues`;
+}
+// createQueue registers a named queue with its retry + concurrency policy
+// and the HTTP consumer that runs its jobs.
+async function createQueue(apiKey, orgId, opts) {
+    const body = { name: opts.name, consumer_url: opts.consumerUrl };
+    if (opts.maxAttempts !== undefined)
+        body.max_attempts = opts.maxAttempts;
+    if (opts.maxConcurrency !== undefined)
+        body.max_concurrency = opts.maxConcurrency;
+    return (0, client_1.request)('POST', queuesBase(orgId), apiKey, body);
+}
+async function listQueues(apiKey, orgId) {
+    const res = await (0, client_1.request)('GET', queuesBase(orgId), apiKey);
+    return res?.queues ?? [];
+}
+async function getQueue(apiKey, orgId, name) {
+    return (0, client_1.request)('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}`, apiKey);
+}
+// enqueueJob is idempotent on (queue, dedup_key). A job with unsucceeded
+// depends_on starts blocked.
+async function enqueueJob(apiKey, orgId, name, opts = {}) {
+    const body = {};
+    if (opts.payload !== undefined)
+        body.payload = opts.payload;
+    if (opts.dedupKey !== undefined)
+        body.dedup_key = opts.dedupKey;
+    if (opts.delaySeconds !== undefined)
+        body.delay_seconds = opts.delaySeconds;
+    if (opts.dependsOn !== undefined)
+        body.depends_on = opts.dependsOn;
+    return (0, client_1.request)('POST', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs`, apiKey, body);
+}
+// listJobs lists a queue's jobs, newest first. `limit` is 1-200.
+async function listJobs(apiKey, orgId, name, opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.status)
+        q.set('status', opts.status);
+    if (opts.limit !== undefined)
+        q.set('limit', String(opts.limit));
+    const qs = q.toString();
+    const res = await (0, client_1.request)('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs${qs ? `?${qs}` : ''}`, apiKey);
+    return res?.jobs ?? [];
+}
+async function getJob(apiKey, orgId, jobId) {
+    return (0, client_1.request)('GET', `${config_1.QUEUE_BASE}/queue/orgs/${encodeURIComponent(orgId)}/jobs/${encodeURIComponent(jobId)}`, apiKey);
+}

package/dist/services.d.ts

@@ -1,5 +1,5 @@
 export type ServiceStatus = 'ga' | 'preview' | 'planned';
-export type ServiceCategory = 'send' | 'capture' | 'data' | 'store' | 'compute' | 'identity' | 'infra';
+export type ServiceCategory = 'send' | 'capture' | 'data' | 'store' | 'compute' | 'orchestrate' | 'identity' | 'infra';
 export interface ServiceMeta {
     /** SDK namespace (also OpenAPI tag and CLI top-level command). */
     module: string;

package/dist/services.js

@@ -171,15 +171,6 @@ exports.SERVICES = [
         keywords: k('kv-store', 'database', 'state'),
     },
     // ── compute ─────────────────────────────────────────────────────────
-    {
-        module: 'workflow',
-        skill: 'my-workflow-api',
-        domain: 'myworkflowapi.com',
-        description: 'React to inbound webhooks with step chains: send email, post to Slack, call HTTP URLs.',
-        category: 'compute',
-        status: 'ga',
-        keywords: k('workflow', 'automation', 'orchestration'),
-    },
     {
         module: 'llm',
         skill: 'my-llm-api',
@@ -248,4 +239,41 @@ exports.SERVICES = [
         status: 'preview',
         keywords: k('git', 'repository', 'version-control', 'commit', 'scm'),
     },
+    // ── orchestrate ─────────────────────────────────────────────────────
+    // Control flow, not actions. workflow = event→action, queue = durable
+    // async machine work, task = work that needs an agent/human decision.
+    // See docs/orchestration-decision-guide.md.
+    {
+        module: 'workflow',
+        skill: 'my-workflow-api',
+        domain: 'myworkflowapi.com',
+        description: 'React to inbound webhooks with step chains: send email, post to Slack, call HTTP URLs.',
+        category: 'orchestrate',
+        status: 'ga',
+        keywords: k('workflow', 'automation', 'orchestration'),
+    },
+    {
+        // CLI top-level command + SDK namespace are both `queue`; skill
+        // directory is `my-queue-api`. A durable HTTP-consumer job queue —
+        // retry/backoff, concurrency caps, dependency DAG.
+        module: 'queue',
+        skill: 'my-queue-api',
+        domain: 'myqueueapi.com',
+        description: 'Durable job queue — enqueue work and have it retried against your HTTP consumer, with concurrency caps and a dependency DAG.',
+        category: 'orchestrate',
+        status: 'preview',
+        keywords: k('queue', 'job-queue', 'background-jobs', 'retry', 'async'),
+    },
+    {
+        // CLI top-level command + SDK namespace are both `task`; skill
+        // directory is `my-task-api`. The agent-task queue — the agent-loop
+        // hot path: file, claim under a lease, resolve.
+        module: 'task',
+        skill: 'my-task-api',
+        domain: 'mytaskapi.com',
+        description: 'Agent-task queue — file units of work, rank them, claim under a lease, then resolve, fail, or cancel. The agent-loop hot path.',
+        category: 'orchestrate',
+        status: 'preview',
+        keywords: k('task', 'task-queue', 'agent-loop', 'work-queue', 'lease'),
+    },
 ];

package/dist/task.d.ts

@@ -0,0 +1,78 @@
+import type { Exposes } from './exposes';
+export declare const EXPOSES: Exposes;
+export type TaskStatus = 'open' | 'claimed' | 'blocked' | 'resolved' | 'failed' | 'cancelled';
+export type TaskImportance = 'low' | 'normal' | 'high' | 'critical';
+export interface ResolveOn {
+    event_type: string;
+    field?: string;
+    value?: string;
+}
+export interface TaskRef {
+    id: string;
+    description: string;
+    score: number;
+}
+export interface Task {
+    id: string;
+    org_id: string;
+    description: string;
+    status: TaskStatus;
+    importance: TaskImportance;
+    score: number;
+    tags: string[];
+    source: string;
+    depends_on: string[];
+    payload_url: string;
+    assignee?: string;
+    resolve_on?: ResolveOn;
+    dedup_key?: string;
+    claimed_by?: string;
+    lease_expires_at?: string;
+    due_at?: string;
+    fail_reason?: string;
+    resolved_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface TaskListMeta {
+    shown: number;
+    total_open: number;
+}
+export interface TaskListResult {
+    tasks: TaskRef[];
+    meta: TaskListMeta;
+}
+export interface CreateTaskOptions {
+    description: string;
+    body?: string;
+    importance?: TaskImportance;
+    dueAt?: string;
+    assignee?: string;
+    tags?: string[];
+    dependsOn?: string[];
+    dedupKey?: string;
+    resolveOn?: ResolveOn;
+    source?: string;
+}
+export interface ListTaskOptions {
+    status?: string;
+    tag?: string;
+    importance?: string;
+    assignee?: string;
+    source?: string;
+    limit?: number;
+}
+export declare function createTask(apiKey: string, orgId: string, opts: CreateTaskOptions): Promise<Task>;
+export declare function listTasks(apiKey: string, orgId: string, opts?: ListTaskOptions): Promise<TaskListResult>;
+export declare function getTask(apiKey: string, orgId: string, id: string): Promise<Task>;
+export declare function getTaskBody(apiKey: string, orgId: string, id: string): Promise<string>;
+export declare function claimTask(apiKey: string, orgId: string, id: string, opts?: {
+    leaseSeconds?: number;
+    worker?: string;
+}): Promise<Task>;
+export declare function extendTask(apiKey: string, orgId: string, id: string, opts?: {
+    leaseSeconds?: number;
+}): Promise<Task>;
+export declare function resolveTask(apiKey: string, orgId: string, id: string): Promise<Task>;
+export declare function failTask(apiKey: string, orgId: string, id: string, reason: string): Promise<Task>;
+export declare function cancelTask(apiKey: string, orgId: string, id: string): Promise<void>;

package/dist/task.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPOSES = void 0;
+exports.createTask = createTask;
+exports.listTasks = listTasks;
+exports.getTask = getTask;
+exports.getTaskBody = getTaskBody;
+exports.claimTask = claimTask;
+exports.extendTask = extendTask;
+exports.resolveTask = resolveTask;
+exports.failTask = failTask;
+exports.cancelTask = cancelTask;
+const client_1 = require("./client");
+const config_1 = require("./config");
+// Backend: my-task-api per myapi-hq/internal/routes/task/. An agent-task
+// queue — the agent-loop hot path. Tasks are created, ranked by score,
+// claimed under a lease, then resolved/failed/cancelled. A task with
+// unresolved depends_on starts blocked; lease expiry auto-reverts a claimed
+// task to open.
+exports.EXPOSES = [
+    'POST /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks/{id}',
+    'DELETE /task/orgs/{org_id}/tasks/{id}',
+    'GET /task/orgs/{org_id}/tasks/{id}/body',
+    'POST /task/orgs/{org_id}/tasks/{id}/claim',
+    'POST /task/orgs/{org_id}/tasks/{id}/extend',
+    'POST /task/orgs/{org_id}/tasks/{id}/fail',
+    'POST /task/orgs/{org_id}/tasks/{id}/resolve',
+];
+function tasksBase(orgId) {
+    return `${config_1.TASK_BASE}/task/orgs/${encodeURIComponent(orgId)}/tasks`;
+}
+function taskBase(orgId, id) {
+    return `${tasksBase(orgId)}/${encodeURIComponent(id)}`;
+}
+// createTask is idempotent on (org_id, dedup_key). A task with unresolved
+// depends_on starts blocked; one with an assignee emails them a magic link.
+async function createTask(apiKey, orgId, opts) {
+    const body = { description: opts.description };
+    if (opts.body !== undefined)
+        body.body = opts.body;
+    if (opts.importance !== undefined)
+        body.importance = opts.importance;
+    if (opts.dueAt !== undefined)
+        body.due_at = opts.dueAt;
+    if (opts.assignee !== undefined)
+        body.assignee = opts.assignee;
+    if (opts.tags !== undefined)
+        body.tags = opts.tags;
+    if (opts.dependsOn !== undefined)
+        body.depends_on = opts.dependsOn;
+    if (opts.dedupKey !== undefined)
+        body.dedup_key = opts.dedupKey;
+    if (opts.resolveOn !== undefined)
+        body.resolve_on = opts.resolveOn;
+    if (opts.source !== undefined)
+        body.source = opts.source;
+    return (0, client_1.request)('POST', tasksBase(orgId), apiKey, body);
+}
+// listTasks returns the ranked open queue (projected to TaskRef) plus the
+// backlog counts. Default: top 20 open tasks by score. The backend nests
+// {shown, total_open} inside the response `data.meta` (not the envelope meta).
+async function listTasks(apiKey, orgId, opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.status)
+        q.set('status', opts.status);
+    if (opts.tag)
+        q.set('tag', opts.tag);
+    if (opts.importance)
+        q.set('importance', opts.importance);
+    if (opts.assignee)
+        q.set('assignee', opts.assignee);
+    if (opts.source)
+        q.set('source', opts.source);
+    if (opts.limit !== undefined)
+        q.set('limit', String(opts.limit));
+    const qs = q.toString();
+    const res = await (0, client_1.request)('GET', `${tasksBase(orgId)}${qs ? `?${qs}` : ''}`, apiKey);
+    const tasks = res?.tasks ?? [];
+    const m = res?.meta ?? {};
+    return {
+        tasks,
+        meta: {
+            shown: typeof m.shown === 'number' ? m.shown : tasks.length,
+            total_open: typeof m.total_open === 'number' ? m.total_open : tasks.length,
+        },
+    };
+}
+// getTask returns the full task object. It deliberately does NOT fetch the
+// Markdown body tier — call getTaskBody for that, once, on commit.
+async function getTask(apiKey, orgId, id) {
+    return (0, client_1.request)('GET', taskBase(orgId, id), apiKey);
+}
+// getTaskBody fetches the body tier — the full Markdown context. Separate
+// call by design: it keeps the list/get path token-cheap. The endpoint
+// returns { task_id, body }.
+async function getTaskBody(apiKey, orgId, id) {
+    const res = await (0, client_1.request)('GET', `${taskBase(orgId, id)}/body`, apiKey);
+    return res?.body ?? '';
+}
+// claimTask takes an atomic lease (default 10 min) and returns the full
+// updated task — lease state is on `lease_expires_at` / `claimed_by`.
+async function claimTask(apiKey, orgId, id, opts = {}) {
+    const body = {};
+    if (opts.leaseSeconds !== undefined)
+        body.lease_seconds = opts.leaseSeconds;
+    if (opts.worker !== undefined)
+        body.worker = opts.worker;
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/claim`, apiKey, body);
+}
+// extendTask is a heartbeat for long work — extends a live claim.
+async function extendTask(apiKey, orgId, id, opts = {}) {
+    const body = {};
+    if (opts.leaseSeconds !== undefined)
+        body.lease_seconds = opts.leaseSeconds;
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/extend`, apiKey, body);
+}
+// resolveTask resolves a task (terminal) — unblocks any dependents.
+async function resolveTask(apiKey, orgId, id) {
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/resolve`, apiKey, {});
+}
+// failTask fails a task (terminal, with a reason). Does not auto-retry;
+// dependents that can never proceed are auto-failed.
+async function failTask(apiKey, orgId, id, reason) {
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/fail`, apiKey, { reason });
+}
+// cancelTask cancels a task (terminal, distinct from fail).
+async function cancelTask(apiKey, orgId, id) {
+    return (0, client_1.request)('DELETE', taskBase(orgId, id), apiKey);
+}

package/dist/workflow.d.ts

@@ -28,6 +28,12 @@ export type WorkflowStep = {
     method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
     body?: string;
     headers?: Record<string, string>;
+} | {
+    type: 'enqueue_job' | 'enqueue';
+    queue: string;
+    payload?: string;
+    dedup_key?: string;
+    delay_seconds?: number;
 };
 export interface Workflow {
     id: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/sdk",
   "license": "Apache-2.0",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "TypeScript SDK for the MyAPI ecosystem",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -72,8 +72,8 @@ export async function request<T>(
     const err = result?.error;
     const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
     const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-    const body = typeof err === 'object' ? err : undefined;
-    throw new MyApiError(code, response.status, detail, body);
+    const errBody = typeof err === 'object' ? err : undefined;
+    throw new MyApiError(code, response.status, detail, errBody);
   }
 
   const apiResponse = result as ApiResponse<T>;
@@ -81,8 +81,8 @@ export async function request<T>(
     const err = apiResponse.error as any;
     const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
     const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-    const body = typeof err === 'object' ? err : undefined;
-    throw new MyApiError(code, response.status, detail, body);
+    const errBody = typeof err === 'object' ? err : undefined;
+    throw new MyApiError(code, response.status, detail, errBody);
   }
 
   return apiResponse.data as T;

package/src/config.ts

@@ -18,6 +18,8 @@ export const FUNCTION_BASE= process.env.MYAPI_FUNCTION_URL?? GATEWAY;
 export const PAYMENTS_BASE= process.env.MYAPI_PAYMENTS_URL?? GATEWAY;
 export const CONTAINER_BASE=process.env.MYAPI_CONTAINER_URL?? GATEWAY;
 export const GIT_BASE     = process.env.MYAPI_GIT_URL     ?? GATEWAY;
+export const QUEUE_BASE   = process.env.MYAPI_QUEUE_URL   ?? GATEWAY;
+export const TASK_BASE    = process.env.MYAPI_TASK_URL    ?? GATEWAY;
 export const IMAGE_BASE   = process.env.MYAPI_IMAGE_URL   ?? 'https://api.myimageapi.com';
 export const WEBHOOK_BASE = process.env.MYAPI_WEBHOOK_URL ?? 'https://api.mywebhookapi.com';
 export const WORKFLOW_BASE= process.env.MYAPI_WORKFLOW_URL?? 'https://api.myworkflowapi.com';

package/src/email.ts

@@ -6,6 +6,8 @@ export const EXPOSES: Exposes = [
   // Mailbox / sending activation
   'POST /email/mailboxes/create',
   'GET /email/mailboxes',
+  'PUT /email/mailboxes/{address}/forwarding',
+  'DELETE /email/mailboxes/{address}/forwarding',
   'POST /email/sending/activate',
   // Send + read
   'POST /email/send',
@@ -151,6 +153,18 @@ export async function activateSending(apiKey: string, address: string): Promise<
   return request('POST', `${BASE_URL}/email/sending/activate`, apiKey, { address });
 }
 
+// setForwarding redirects a copy of every incoming message to an external
+// address (server-side; the original is kept in the mailbox). `forwardTo`
+// must be a valid address and cannot equal the mailbox itself.
+export async function setForwarding(apiKey: string, address: string, forwardTo: string): Promise<{ address: string; forward_to: string }> {
+  return request('PUT', `${BASE_URL}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey, { forward_to: forwardTo });
+}
+
+// deleteForwarding stops forwarding for a mailbox.
+export async function deleteForwarding(apiKey: string, address: string): Promise<void> {
+  return request('DELETE', `${BASE_URL}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey);
+}
+
 // ── Sending and reading (account-scoped) ─────────────────────────────────────
 
 export async function sendEmail(apiKey: string, payload: { from: string; to: string[]; subject: string; html?: string; text?: string; template_id?: string; template_vars?: Record<string, string> }): Promise<{ message_id: string }> {

package/src/index.ts

@@ -26,3 +26,5 @@ export * as fn from './function';
 export * as payments from './payments';
 export * as container from './container';
 export * as git from './git';
+export * as queue from './queue';
+export * as task from './task';

package/src/queue.ts

@@ -0,0 +1,110 @@
+import { request } from './client';
+import { QUEUE_BASE as BASE_URL } from './config';
+import type { Exposes } from './exposes';
+
+// Backend: my-queue-api per myapi-hq/internal/routes/queue/. A durable
+// HTTP-consumer job queue — each named queue POSTs its jobs to a configured
+// consumer_url, with retry/backoff to max_attempts, a concurrency cap, and a
+// dependency DAG (a job with unsucceeded depends_on starts blocked).
+export const EXPOSES: Exposes = [
+  'POST /queue/orgs/{org_id}/queues',
+  'GET /queue/orgs/{org_id}/queues',
+  'GET /queue/orgs/{org_id}/queues/{name}',
+  'POST /queue/orgs/{org_id}/queues/{name}/jobs',
+  'GET /queue/orgs/{org_id}/queues/{name}/jobs',
+  'GET /queue/orgs/{org_id}/jobs/{id}',
+];
+
+export interface Queue {
+  id: string;
+  org_id: string;
+  name: string;
+  consumer_url: string;
+  max_attempts: number;
+  max_concurrency: number;
+  created_at: string;
+}
+
+// A job that exhausts max_attempts goes straight to `dead` — there is no
+// separate `failed` state.
+export type JobStatus = 'pending' | 'blocked' | 'running' | 'succeeded' | 'dead';
+
+export interface Job {
+  id: string;
+  queue_id: string;
+  org_id: string;
+  payload: unknown;
+  status: JobStatus;
+  attempt: number;
+  max_attempts: number;
+  not_before: string;
+  depends_on: string[];
+  dedup_key?: string;
+  last_error?: string;
+  started_at?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CreateQueueOptions {
+  name: string;
+  consumerUrl: string;
+  maxAttempts?: number;
+  maxConcurrency?: number;
+}
+
+export interface EnqueueOptions {
+  payload?: unknown;
+  dedupKey?: string;
+  delaySeconds?: number;
+  // Job ids this job waits on. Immutable — the DAG is declared at enqueue.
+  // Same shape as task.create's depends_on.
+  dependsOn?: string[];
+}
+
+function queuesBase(orgId: string): string {
+  return `${BASE_URL}/queue/orgs/${encodeURIComponent(orgId)}/queues`;
+}
+
+// createQueue registers a named queue with its retry + concurrency policy
+// and the HTTP consumer that runs its jobs.
+export async function createQueue(apiKey: string, orgId: string, opts: CreateQueueOptions): Promise<Queue> {
+  const body: Record<string, unknown> = { name: opts.name, consumer_url: opts.consumerUrl };
+  if (opts.maxAttempts !== undefined) body.max_attempts = opts.maxAttempts;
+  if (opts.maxConcurrency !== undefined) body.max_concurrency = opts.maxConcurrency;
+  return request('POST', queuesBase(orgId), apiKey, body);
+}
+
+export async function listQueues(apiKey: string, orgId: string): Promise<Queue[]> {
+  const res = await request<{ queues?: Queue[] }>('GET', queuesBase(orgId), apiKey);
+  return res?.queues ?? [];
+}
+
+export async function getQueue(apiKey: string, orgId: string, name: string): Promise<Queue> {
+  return request('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}`, apiKey);
+}
+
+// enqueueJob is idempotent on (queue, dedup_key). A job with unsucceeded
+// depends_on starts blocked.
+export async function enqueueJob(apiKey: string, orgId: string, name: string, opts: EnqueueOptions = {}): Promise<Job> {
+  const body: Record<string, unknown> = {};
+  if (opts.payload !== undefined) body.payload = opts.payload;
+  if (opts.dedupKey !== undefined) body.dedup_key = opts.dedupKey;
+  if (opts.delaySeconds !== undefined) body.delay_seconds = opts.delaySeconds;
+  if (opts.dependsOn !== undefined) body.depends_on = opts.dependsOn;
+  return request('POST', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs`, apiKey, body);
+}
+
+// listJobs lists a queue's jobs, newest first. `limit` is 1-200.
+export async function listJobs(apiKey: string, orgId: string, name: string, opts: { status?: string; limit?: number } = {}): Promise<Job[]> {
+  const q = new URLSearchParams();
+  if (opts.status) q.set('status', opts.status);
+  if (opts.limit !== undefined) q.set('limit', String(opts.limit));
+  const qs = q.toString();
+  const res = await request<{ jobs?: Job[] }>('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs${qs ? `?${qs}` : ''}`, apiKey);
+  return res?.jobs ?? [];
+}
+
+export async function getJob(apiKey: string, orgId: string, jobId: string): Promise<Job> {
+  return request('GET', `${BASE_URL}/queue/orgs/${encodeURIComponent(orgId)}/jobs/${encodeURIComponent(jobId)}`, apiKey);
+}

package/src/services.ts

@@ -20,7 +20,8 @@ export type ServiceCategory =
   | 'capture'   // inbound: webhook, pixel
   | 'data'      // read/filter the data layer: people, company, audience, crm
   | 'store'     // persist bytes/JSON: storage, database
-  | 'compute'   // run code or inference: llm, workflow
+  | 'compute'   // run code or inference: llm, fn
+  | 'orchestrate' // control flow: workflow, queue, task
   | 'identity'  // auth/billing/account: hq
   | 'infra';    // platform glue: domain
 
@@ -201,15 +202,6 @@ export const SERVICES: readonly ServiceMeta[] = [
   },
 
   // ── compute ─────────────────────────────────────────────────────────
-  {
-    module: 'workflow',
-    skill: 'my-workflow-api',
-    domain: 'myworkflowapi.com',
-    description: 'React to inbound webhooks with step chains: send email, post to Slack, call HTTP URLs.',
-    category: 'compute',
-    status: 'ga',
-    keywords: k('workflow', 'automation', 'orchestration'),
-  },
   {
     module: 'llm',
     skill: 'my-llm-api',
@@ -278,4 +270,42 @@ export const SERVICES: readonly ServiceMeta[] = [
     status: 'preview',
     keywords: k('git', 'repository', 'version-control', 'commit', 'scm'),
   },
+
+  // ── orchestrate ─────────────────────────────────────────────────────
+  // Control flow, not actions. workflow = event→action, queue = durable
+  // async machine work, task = work that needs an agent/human decision.
+  // See docs/orchestration-decision-guide.md.
+  {
+    module: 'workflow',
+    skill: 'my-workflow-api',
+    domain: 'myworkflowapi.com',
+    description: 'React to inbound webhooks with step chains: send email, post to Slack, call HTTP URLs.',
+    category: 'orchestrate',
+    status: 'ga',
+    keywords: k('workflow', 'automation', 'orchestration'),
+  },
+  {
+    // CLI top-level command + SDK namespace are both `queue`; skill
+    // directory is `my-queue-api`. A durable HTTP-consumer job queue —
+    // retry/backoff, concurrency caps, dependency DAG.
+    module: 'queue',
+    skill: 'my-queue-api',
+    domain: 'myqueueapi.com',
+    description: 'Durable job queue — enqueue work and have it retried against your HTTP consumer, with concurrency caps and a dependency DAG.',
+    category: 'orchestrate',
+    status: 'preview',
+    keywords: k('queue', 'job-queue', 'background-jobs', 'retry', 'async'),
+  },
+  {
+    // CLI top-level command + SDK namespace are both `task`; skill
+    // directory is `my-task-api`. The agent-task queue — the agent-loop
+    // hot path: file, claim under a lease, resolve.
+    module: 'task',
+    skill: 'my-task-api',
+    domain: 'mytaskapi.com',
+    description: 'Agent-task queue — file units of work, rank them, claim under a lease, then resolve, fail, or cancel. The agent-loop hot path.',
+    category: 'orchestrate',
+    status: 'preview',
+    keywords: k('task', 'task-queue', 'agent-loop', 'work-queue', 'lease'),
+  },
 ] as const;

package/src/task.ts

@@ -0,0 +1,198 @@
+import { request } from './client';
+import { TASK_BASE as BASE_URL } from './config';
+import type { Exposes } from './exposes';
+
+// Backend: my-task-api per myapi-hq/internal/routes/task/. An agent-task
+// queue — the agent-loop hot path. Tasks are created, ranked by score,
+// claimed under a lease, then resolved/failed/cancelled. A task with
+// unresolved depends_on starts blocked; lease expiry auto-reverts a claimed
+// task to open.
+export const EXPOSES: Exposes = [
+  'POST /task/orgs/{org_id}/tasks',
+  'GET /task/orgs/{org_id}/tasks',
+  'GET /task/orgs/{org_id}/tasks/{id}',
+  'DELETE /task/orgs/{org_id}/tasks/{id}',
+  'GET /task/orgs/{org_id}/tasks/{id}/body',
+  'POST /task/orgs/{org_id}/tasks/{id}/claim',
+  'POST /task/orgs/{org_id}/tasks/{id}/extend',
+  'POST /task/orgs/{org_id}/tasks/{id}/fail',
+  'POST /task/orgs/{org_id}/tasks/{id}/resolve',
+];
+
+export type TaskStatus = 'open' | 'claimed' | 'blocked' | 'resolved' | 'failed' | 'cancelled';
+
+export type TaskImportance = 'low' | 'normal' | 'high' | 'critical';
+
+// Event matcher: a matching platform_events delivery auto-resolves the task.
+export interface ResolveOn {
+  event_type: string;
+  field?: string;
+  value?: string;
+}
+
+// The projected list row — list deliberately returns only this triage-sized
+// shape, not the full task. Read the body tier separately via getTaskBody.
+export interface TaskRef {
+  id: string;
+  description: string;
+  score: number;
+}
+
+// Full task object. `claim` and `extend` return this — lease state is read
+// off `lease_expires_at` / `claimed_by`, not a separate lease object.
+export interface Task {
+  id: string;
+  org_id: string;
+  description: string;
+  status: TaskStatus;
+  importance: TaskImportance;
+  score: number;
+  tags: string[];
+  source: string;
+  depends_on: string[];
+  payload_url: string;
+  assignee?: string;
+  resolve_on?: ResolveOn;
+  dedup_key?: string;
+  claimed_by?: string;
+  lease_expires_at?: string;
+  due_at?: string;
+  fail_reason?: string;
+  resolved_at?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+// Backlog health from the list envelope's meta — the agent's "am I keeping
+// up" signal. `shown` is how many rows came back; `total_open` is the whole
+// open queue depth.
+export interface TaskListMeta {
+  shown: number;
+  total_open: number;
+}
+
+export interface TaskListResult {
+  tasks: TaskRef[];
+  meta: TaskListMeta;
+}
+
+export interface CreateTaskOptions {
+  description: string;
+  // Full Markdown context. Staged to the body tier; read once via getTaskBody.
+  body?: string;
+  importance?: TaskImportance;
+  dueAt?: string;
+  assignee?: string;
+  tags?: string[];
+  // Task ids this task waits on. Immutable — declared only at creation.
+  // Same shape as queue.enqueue's depends_on.
+  dependsOn?: string[];
+  dedupKey?: string;
+  resolveOn?: ResolveOn;
+  source?: string;
+}
+
+export interface ListTaskOptions {
+  status?: string;
+  tag?: string;
+  importance?: string;
+  assignee?: string;
+  source?: string;
+  limit?: number;
+}
+
+function tasksBase(orgId: string): string {
+  return `${BASE_URL}/task/orgs/${encodeURIComponent(orgId)}/tasks`;
+}
+
+function taskBase(orgId: string, id: string): string {
+  return `${tasksBase(orgId)}/${encodeURIComponent(id)}`;
+}
+
+// createTask is idempotent on (org_id, dedup_key). A task with unresolved
+// depends_on starts blocked; one with an assignee emails them a magic link.
+export async function createTask(apiKey: string, orgId: string, opts: CreateTaskOptions): Promise<Task> {
+  const body: Record<string, unknown> = { description: opts.description };
+  if (opts.body !== undefined) body.body = opts.body;
+  if (opts.importance !== undefined) body.importance = opts.importance;
+  if (opts.dueAt !== undefined) body.due_at = opts.dueAt;
+  if (opts.assignee !== undefined) body.assignee = opts.assignee;
+  if (opts.tags !== undefined) body.tags = opts.tags;
+  if (opts.dependsOn !== undefined) body.depends_on = opts.dependsOn;
+  if (opts.dedupKey !== undefined) body.dedup_key = opts.dedupKey;
+  if (opts.resolveOn !== undefined) body.resolve_on = opts.resolveOn;
+  if (opts.source !== undefined) body.source = opts.source;
+  return request('POST', tasksBase(orgId), apiKey, body);
+}
+
+// listTasks returns the ranked open queue (projected to TaskRef) plus the
+// backlog counts. Default: top 20 open tasks by score. The backend nests
+// {shown, total_open} inside the response `data.meta` (not the envelope meta).
+export async function listTasks(apiKey: string, orgId: string, opts: ListTaskOptions = {}): Promise<TaskListResult> {
+  const q = new URLSearchParams();
+  if (opts.status) q.set('status', opts.status);
+  if (opts.tag) q.set('tag', opts.tag);
+  if (opts.importance) q.set('importance', opts.importance);
+  if (opts.assignee) q.set('assignee', opts.assignee);
+  if (opts.source) q.set('source', opts.source);
+  if (opts.limit !== undefined) q.set('limit', String(opts.limit));
+  const qs = q.toString();
+  const res = await request<{ tasks?: TaskRef[]; meta?: Partial<TaskListMeta> }>(
+    'GET', `${tasksBase(orgId)}${qs ? `?${qs}` : ''}`, apiKey,
+  );
+  const tasks = res?.tasks ?? [];
+  const m = res?.meta ?? {};
+  return {
+    tasks,
+    meta: {
+      shown: typeof m.shown === 'number' ? m.shown : tasks.length,
+      total_open: typeof m.total_open === 'number' ? m.total_open : tasks.length,
+    },
+  };
+}
+
+// getTask returns the full task object. It deliberately does NOT fetch the
+// Markdown body tier — call getTaskBody for that, once, on commit.
+export async function getTask(apiKey: string, orgId: string, id: string): Promise<Task> {
+  return request('GET', taskBase(orgId, id), apiKey);
+}
+
+// getTaskBody fetches the body tier — the full Markdown context. Separate
+// call by design: it keeps the list/get path token-cheap. The endpoint
+// returns { task_id, body }.
+export async function getTaskBody(apiKey: string, orgId: string, id: string): Promise<string> {
+  const res = await request<{ task_id: string; body: string }>('GET', `${taskBase(orgId, id)}/body`, apiKey);
+  return res?.body ?? '';
+}
+
+// claimTask takes an atomic lease (default 10 min) and returns the full
+// updated task — lease state is on `lease_expires_at` / `claimed_by`.
+export async function claimTask(apiKey: string, orgId: string, id: string, opts: { leaseSeconds?: number; worker?: string } = {}): Promise<Task> {
+  const body: Record<string, unknown> = {};
+  if (opts.leaseSeconds !== undefined) body.lease_seconds = opts.leaseSeconds;
+  if (opts.worker !== undefined) body.worker = opts.worker;
+  return request('POST', `${taskBase(orgId, id)}/claim`, apiKey, body);
+}
+
+// extendTask is a heartbeat for long work — extends a live claim.
+export async function extendTask(apiKey: string, orgId: string, id: string, opts: { leaseSeconds?: number } = {}): Promise<Task> {
+  const body: Record<string, unknown> = {};
+  if (opts.leaseSeconds !== undefined) body.lease_seconds = opts.leaseSeconds;
+  return request('POST', `${taskBase(orgId, id)}/extend`, apiKey, body);
+}
+
+// resolveTask resolves a task (terminal) — unblocks any dependents.
+export async function resolveTask(apiKey: string, orgId: string, id: string): Promise<Task> {
+  return request('POST', `${taskBase(orgId, id)}/resolve`, apiKey, {});
+}
+
+// failTask fails a task (terminal, with a reason). Does not auto-retry;
+// dependents that can never proceed are auto-failed.
+export async function failTask(apiKey: string, orgId: string, id: string, reason: string): Promise<Task> {
+  return request('POST', `${taskBase(orgId, id)}/fail`, apiKey, { reason });
+}
+
+// cancelTask cancels a task (terminal, distinct from fail).
+export async function cancelTask(apiKey: string, orgId: string, id: string): Promise<void> {
+  return request('DELETE', taskBase(orgId, id), apiKey);
+}

package/src/workflow.ts

@@ -33,7 +33,13 @@ export type WorkflowStep =
   // Backend (2026-05-15): `http_request` step is now accepted (alias: `http`).
   // POSTs (or other method) to `url` with the inbound payload; supports
   // template substitution in url/body the same way email steps do.
-  | { type: 'http_request' | 'http'; url: string; method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'; body?: string; headers?: Record<string, string> };
+  | { type: 'http_request' | 'http'; url: string; method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'; body?: string; headers?: Record<string, string> }
+  // `enqueue_job` (alias: `enqueue`) hands durable work to my-queue-api —
+  // the step enqueues a job on `queue` carrying `payload` (template
+  // substitution supported, same as email/http steps). The workflow stays
+  // the trigger layer; the queue owns retry/durability. Backend: pending —
+  // see docs/cross-repo-prompts/backend-orchestration-composition.md.
+  | { type: 'enqueue_job' | 'enqueue'; queue: string; payload?: string; dedup_key?: string; delay_seconds?: number };
 
 export interface Workflow {
   id: string;