@oxygen-agent/cli 1.1011.326 → 1.1011.440

package/node_modules/@oxygen/shared/dist/contracts/customer-operations.js

@@ -0,0 +1,131 @@
+/** Customer operations missing from one execution surface, with one field contract. */
+import { arr, bool, enumOf, int, nullable, num, obj, str } from "./schema.js";
+import { DATABASE_ATTACH_CONTRACT, DATABASE_MIGRATE_CONTRACT, DATABASE_QUERY_CONTRACT } from "./database.js";
+const text = (description) => str(description === undefined ? {} : { description });
+const list = () => arr(str());
+const json = { type: "object", additionalProperties: true };
+const rows = () => arr(json);
+function operation(id, route, method, cli, mcp, pack, summary, fields = {}, required = [], options = {}) {
+    const { annotations, ...behavior } = options;
+    const parameters = [...route.matchAll(/\{(\w+)\}/g)].map((match) => match[1]);
+    return {
+        id, route, method, parameters,
+        contract: obj(fields, { required }),
+        cli: { path: cli.split(" "), summary },
+        mcp: { name: mcp, title: `Oxygen: ${cli}`, description: summary, pack, ...(annotations ? { annotations } : {}) },
+        mutates: method !== "GET", spends: false, ...behavior,
+    };
+}
+const mcpOnly = { generated: { cli: false, mcp: true } };
+const cliOnly = { generated: { cli: true, mcp: false } };
+export const CUSTOMER_OPERATIONS = [
+    operation("activation.state", "/api/cli/activation/state", "GET", "activation state", "oxygen_activation_state", "workspace", "Read this workspace's onboarding activation state and next available actions.", {}, [], mcpOnly),
+    operation("api_keys.list", "/api/cli/api-keys", "GET", "api-keys list", "oxygen_api_keys_list", "workspace", "List workspace API keys without revealing their tokens.", {}, [], mcpOnly),
+    operation("api_keys.create", "/api/cli/api-keys", "POST", "api-keys create", "oxygen_api_keys_create", "workspace", "Create a workspace API key; requires the caller's personal user session. The token is returned once.", { name: text(), expires_at: text("ISO timestamp; omit for no expiry.") }, [], mcpOnly),
+    operation("api_keys.revoke", "/api/cli/api-keys/{key_id}", "DELETE", "api-keys revoke", "oxygen_api_keys_revoke", "workspace", "Revoke a workspace API key; requires the caller's personal user session.", {}, [], mcpOnly),
+    operation("comments.edit", "/api/cli/collab/comments/{comment_id}", "PATCH", "comments edit", "oxygen_comments_edit", "collaboration", "Edit your own internal workspace comment; records the edit time.", { body: text() }, ["body"], mcpOnly),
+    operation("comments.delete", "/api/cli/collab/comments/{comment_id}", "DELETE", "comments delete", "oxygen_comments_delete", "collaboration", "Retract your own internal workspace comment while retaining its audit trail.", {}, [], mcpOnly),
+    operation("approvals.cancel", "/api/cli/collab/requests/{request_id}/cancel", "POST", "approvals cancel", "oxygen_approvals_cancel", "collaboration", "Withdraw an approval request you created; grants no approval.", { note: text() }, [], mcpOnly),
+    operation("members.client_role", "/api/cli/collab/members/role", "POST", "approvals client grant", "oxygen_members_client_role_set", "collaboration", "Set or clear a member's restricted client role; workspace admin only.", { email: text(), role: nullable(enumOf(["client"])) }, ["email", "role"], mcpOnly),
+    operation("members.workspace_role", "/api/cli/collab/members/workspace-role", "POST", "orgs member-role", "oxygen_members_workspace_role_set", "collaboration", "Change a member's workspace role; admin only and the last administrator is protected.", { email: text(), role: enumOf(["admin", "member"]) }, ["email", "role"], mcpOnly),
+    operation("copilot.sessions.list", "/api/cli/copilot/sessions", "GET", "copilot list", "oxygen_copilot_sessions_list", "agents", "List attended Copilot sessions in this workspace.", { status: text(), limit: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("copilot.sessions.update", "/api/cli/copilot/sessions/{session_id}", "PATCH", "copilot policy set", "oxygen_copilot_session_update", "agents", "Set an attended Copilot session's approval and screen-follow policies. Paid auto-approval is explicit standing authorization.", { auto_approve_policy: enumOf(["off", "paid"]), surface_policy: enumOf(["off", "follow"]) }, [], { spends: true }),
+    operation("copilot.attachments.list", "/api/cli/copilot/sessions/{session_id}/attachments", "GET", "copilot attachments list", "oxygen_copilot_attachments_list", "agents", "List sent and unsent attachments in one Copilot session.", {}, []),
+    operation("copilot.attachments.prepare", "/api/cli/copilot/sessions/{session_id}/attachments", "POST", "copilot attachments prepare", "oxygen_copilot_attachment_prepare", "agents", "Reserve a Copilot attachment and return its scoped upload URL; complete only after uploading the exact bytes.", { file_name: text(), content_type: text(), content_length: int({ minimum: 1 }) }, ["file_name", "content_length"]),
+    operation("copilot.attachments.complete", "/api/cli/copilot/sessions/{session_id}/attachments/{attachment_id}/complete", "POST", "copilot attachments complete", "oxygen_copilot_attachment_complete", "agents", "Verify and describe an uploaded Copilot attachment in its session.", {}, []),
+    operation("copilot.attachments.delete", "/api/cli/copilot/sessions/{session_id}/attachments/{attachment_id}", "DELETE", "copilot attachments delete", "oxygen_copilot_attachment_delete", "agents", "Detach an unsent Copilot attachment; attachments already quoted by a turn cannot be removed."),
+    operation("copilot.feedback", "/api/cli/copilot/sessions/{session_id}/turns/{turn_id}/feedback", "POST", "copilot feedback", "oxygen_copilot_feedback", "agents", "Rate one attended Copilot turn and optionally explain the rating.", { rating: enumOf(["up", "down"]), comment: text() }, ["rating"]),
+    operation("copilot.interrupt", "/api/cli/copilot/sessions/{session_id}/turns/{turn_id}/interrupt", "POST", "copilot interrupt", "oxygen_copilot_interrupt", "agents", "Request cancellation of one Copilot turn. Read the session again to confirm it stopped.", {}, [], mcpOnly),
+    operation("context.canonical.get", "/api/cli/context/canonical/get", "POST", "context canonical get", "oxygen_context_canonical_get", "knowledge", "Read the pinned active context asset for a type; present=false means none is set.", { type: text() }, ["type"], { mutates: false }),
+    operation("crm.notes.update", "/api/cli/crm/notes/{note_id}", "PATCH", "crm notes update", "oxygen_crm_note_update", "crm", "Edit a CRM note's body, title or pinned state; an empty title clears it.", { body: text(), title: nullable(text()), pinned: bool() }, [], mcpOnly),
+    operation("crm.notes.delete", "/api/cli/crm/notes/{note_id}", "DELETE", "crm notes delete", "oxygen_crm_note_delete", "crm", "Delete one CRM note in this workspace.", {}, [], mcpOnly),
+    operation("crm.files.attach_inline", "/api/cli/crm/objects/{object}/records/{row_id}/files", "POST", "crm files attach-inline", "oxygen_crm_file_attach", "crm", "Attach base64 file bytes to one CRM record. For larger files use prepare-upload and complete-upload.", { name: text(), content_base64: text(), label: text() }, ["name", "content_base64"]),
+    operation("crm.files.prepare", "/api/cli/crm/objects/{object}/records/{row_id}/files/upload-url", "POST", "crm files prepare-upload", "oxygen_crm_file_prepare_upload", "crm", "Reserve a CRM file upload by exact name, length and SHA-256; returns a scoped upload URL.", { name: text(), byte_length: int({ minimum: 0 }), sha256: text() }, ["name", "byte_length", "sha256"]),
+    operation("crm.files.complete", "/api/cli/crm/objects/{object}/records/{row_id}/files/{file_id}/uploaded", "POST", "crm files complete-upload", "oxygen_crm_file_complete_upload", "crm", "Verify a reserved CRM upload and attach it to its record; mismatched bytes remain pending.", { label: text() }),
+    operation("crm.files.delete", "/api/cli/crm/files/{attachment_id}", "DELETE", "crm files detach", "oxygen_crm_file_delete", "crm", "Detach a CRM attachment by attachment_id, preserving the stored file.", {}, [], mcpOnly),
+    operation("crm.photos", "/api/cli/crm/photos", "POST", "crm photos", "oxygen_crm_photos_backfill", "crm", "Preview or fill people photos from data this workspace already holds. Free; mode defaults to dry_run.", { mode: enumOf(["dry_run", "live"]), limit: int({ minimum: 1, maximum: 10000 }) }, [], mcpOnly),
+    operation("dashboards.tabs.create", "/api/cli/dashboards/{dashboard_id}/tabs", "POST", "dashboards tabs add", "oxygen_dashboard_tab_create", "signals", "Create a named tab in a workspace dashboard.", { title: text() }, ["title"], mcpOnly),
+    operation("dashboards.tabs.delete", "/api/cli/dashboards/{dashboard_id}/tabs", "DELETE", "dashboards tabs remove", "oxygen_dashboard_tab_delete", "signals", "Remove one dashboard tab by its id.", { tab: text() }, ["tab"], { ...mcpOnly, queryFields: ["tab"] }),
+    operation("integrations.custom.connect", "/api/cli/custom-integrations/connect", "POST", "custom-integrations connect", "oxygen_custom_integration_connect", "integrations", "Store an encrypted API key for an applied custom HTTP integration; the secret is never returned.", { slug: text(), api_key: text() }, ["slug", "api_key"], mcpOnly),
+    operation("integrations.connections", "/api/cli/integrations/connections", "GET", "integrations connections", "oxygen_integrations_connections", "integrations", "List this workspace's stored integration connections and health without credentials.", { integration_id: text() }),
+    operation("db.attach", "/api/cli/db/attach", "POST", "db attach", "oxygen_database_attach", "workspace", "Attach an owned PostgreSQL database and initialize this workspace's schema/roles immediately. Changes the workspace database; no preview or confirmation field. Native workspace write access applies. Use Supabase import tools for external Tables. 0 credits.", {}, [], { ...mcpOnly, contract: DATABASE_ATTACH_CONTRACT, annotations: { destructiveHint: true, openWorldHint: true } }),
+    operation("db.migrate", "/api/cli/db/migrate", "POST", "db migrate", "oxygen_database_migrate", "workspace", "Apply pending workspace database migrations immediately; optionally repair runtime/read passwords. Read oxygen_workspace_database_status first. No preview or confirmation field; native workspace write access applies. Fleet repair remains separate. 0 credits.", {}, [], { ...mcpOnly, contract: DATABASE_MIGRATE_CONTRACT, annotations: { destructiveHint: true } }),
+    operation("db.query", "/api/cli/db/query", "POST", "db query", "oxygen_database_query", "workspace", "Read this workspace's database with one bounded SQL statement. Complete rows, default 20, maximum 1000; writes refused. On truncation, narrow SELECT/WHERE or use your own stable ORDER BY/keyset predicate; no server cursor. 0 credits.", {}, [], { contract: DATABASE_QUERY_CONTRACT, generated: { cli: false, mcp: false }, mutates: false }),
+    operation("db.cost_policy.reconcile", "/api/cli/db/reconcile-cost-policy", "POST", "db reconcile-cost-policy", "oxygen_database_cost_policy_reconcile", "workspace", "Retired Neon compatibility action: reports applied=false with no operations; does not suspend PostgreSQL. Native workspace write access applies; no preview or confirmation field. 0 credits.", { suspend_idle: bool() }, [], mcpOnly),
+    operation("directory.apply", "/api/cli/directory/apply", "POST", "directory apply", "oxygen_directory_apply", "crm", "Apply for an agency-directory listing for this workspace; reuses an existing open application.", { message: text(), website: text() }, [], mcpOnly),
+    operation("directory.logo", "/api/cli/directory/listing/logo", "POST", "directory logo upload", "oxygen_directory_logo_upload", "crm", "Upload a public agency-directory logo and read back the updated listing; PNG, JPEG, WebP or SVG, at most 2 MB.", { content_base64: text(), file_name: text(), content_type: enumOf(["image/png", "image/jpeg", "image/webp", "image/svg+xml"]) }, ["content_base64", "file_name", "content_type"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
+    operation("domains.delete", "/api/cli/domains/delete", "POST", "domains delete", "oxygen_domains_delete", "deliverability", "Preview domain removal and renewal cancellation; execute only with the exact plan hash and confirmation.", { domains: list(), approved: bool(), plan_hash: text(), confirmation: text() }, ["domains"], mcpOnly),
+    operation("knowledge.pages.archive", "/api/cli/knowledge/pages/archive", "POST", "knowledge page archive", "oxygen_knowledge_page_archive", "knowledge", "Archive a knowledge page while preserving its history.", { slug: text(), id: text(), expected_revision: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("knowledge.sync.manifest", "/api/cli/knowledge/sync/manifest", "POST", "knowledge sync-manifest", "oxygen_knowledge_sync_manifest", "knowledge", "Read the wiki revision and content-hash inventory without downloading instruction bodies.", {}, [], { mutates: false }),
+    operation("knowledge.sync.delta", "/api/cli/knowledge/sync/delta", "POST", "knowledge sync", "oxygen_knowledge_sync_delta", "knowledge", "Read one resumable batch of wiki pages and tombstones, bounded by the server's byte budget.", { cursor: text(), limit: int({ minimum: 1, maximum: 200 }) }, [], { ...mcpOnly, mutates: false }),
+    operation("limits.provider.get", "/api/cli/limits/provider", "GET", "limits provider list", "oxygen_provider_limits_list", "billing", "Read effective workspace provider rate limits.", { provider: text() }, [], mcpOnly),
+    operation("limits.provider.set", "/api/cli/limits/provider", "POST", "limits provider set", "oxygen_provider_limits_set", "billing", "Set a workspace provider rate limit; admin or owner only.", { provider: text(), operation: text(), limit: int({ minimum: 1 }), window_seconds: int({ minimum: 1 }) }, ["provider", "limit", "window_seconds"], mcpOnly),
+    operation("limits.provider.delete", "/api/cli/limits/provider", "DELETE", "limits provider delete", "oxygen_provider_limits_delete", "billing", "Clear a workspace provider rate-limit override; admin or owner only.", { provider: text(), operation: text() }, ["provider"], { ...mcpOnly, queryFields: ["provider", "operation"] }),
+    operation("mailboxes.emailguard.auto_enroll.get", "/api/cli/mailboxes/emailguard/auto-enroll", "GET", "mailboxes emailguard auto-enroll", "oxygen_mailboxes_emailguard_auto_enroll_get", "deliverability", "Read the workspace's automatic monitoring enrollment grant and last sweep.", {}, [], mcpOnly),
+    operation("mailboxes.emailguard.auto_enroll.set", "/api/cli/mailboxes/emailguard/auto-enroll", "POST", "mailboxes emailguard auto-enroll", "oxygen_mailboxes_emailguard_auto_enroll_set", "deliverability", "Preview, arm or disarm automatic mailbox monitoring. Arming recurring spend requires approved=true and max_credits_per_cycle.", { enabled: bool(), approved: bool(), max_credits_per_cycle: num({ minimum: 0 }), run: bool(), dry_run: bool() }, [], { ...mcpOnly, spends: true }),
+    operation("mailboxes.warmup_profiles.get", "/api/cli/mailboxes/warmup-profile", "GET", "mailboxes warmup profile", "oxygen_mailboxes_warmup_profiles", "deliverability", "Read available OXYGEN Warm-up profiles and current bindings.", {}, [], mcpOnly),
+    operation("mailboxes.warmup_profiles.set", "/api/cli/mailboxes/warmup-profile", "POST", "mailboxes warmup profile", "oxygen_mailboxes_warmup_profile_set", "deliverability", "Preview or apply an OXYGEN Warm-up profile to exact mailboxes or domains; approved=true applies the reviewed scope.", { profile: { oneOf: [text(), json, { type: "null" }] }, budget: nullable(json), domains: list(), mailboxes: list(), all: bool(), approved: bool() }, [], mcpOnly),
+    operation("managed_inboxes.avatars.prepare", "/api/cli/managed-inboxes/avatars", "POST", "managed-inboxes avatars prepare", "oxygen_managed_inbox_avatar_prepare", "deliverability", "Prepare a scoped mailbox profile-picture upload; confirm the stored bytes before using its URL.", { content_type: enumOf(["image/png", "image/jpeg", "image/webp"]), content_length: int({ minimum: 1 }) }, ["content_length"]),
+    operation("managed_inboxes.avatars.confirm", "/api/cli/managed-inboxes/avatars", "PATCH", "managed-inboxes avatars confirm", "oxygen_managed_inbox_avatar_confirm", "deliverability", "Verify and normalize a mailbox profile picture owned by this workspace.", { storage_key: text() }, ["storage_key"]),
+    operation("managed_inboxes.domains.search", "/api/cli/managed-inboxes/domains/search", "POST", "managed-inboxes search-domains", "oxygen_managed_inbox_domains_search", "deliverability", "Search available domains for managed mailboxes; buys nothing.", { keyword: text(), tlds: list(), limit: int({ minimum: 1 }) }, ["keyword"], { mutates: false }),
+    operation("publishing.drafts.update", "/api/cli/publishing/drafts/{draft_id}", "PATCH", "publishing drafts edit", "oxygen_publishing_draft_update", "publishing", "Edit a queued publishing draft's text without publishing it.", { text: text(), variant_index: int({ minimum: 0 }) }, ["text"], mcpOnly),
+    operation("publishing.mentions.search", "/api/cli/publishing/mentions/search", "POST", "publishing mentions search", "oxygen_publishing_mentions_search", "publishing", "Find LinkedIn company or person identities for a mention; free, subject to the connected account's read quota.", { query: text(), kind: enumOf(["company", "person"]), connection_id: text() }, ["query"], { mutates: false }),
+    operation("settings.beta.get", "/api/cli/settings/beta-features", "GET", "settings beta-features get", "oxygen_settings_beta_features_get", "workspace", "Read this workspace's beta-navigation opt-in."),
+    operation("settings.beta.set", "/api/cli/settings/beta-features", "POST", "settings beta-features set", "oxygen_settings_beta_features_set", "workspace", "Enable or disable beta navigation for this workspace; admin or owner only.", { enabled: bool() }, ["enabled"]),
+    operation("spintax.generate", "/api/cli/spintax", "POST", "spintax generate", "oxygen_spintax_generate", "sequences", "Generate spintax for outreach text. Costs exactly 3 credits; failed generation refunds the reservation.", { text: str({ minLength: 1, maxLength: 4000 }), section: str({ maxLength: 80 }) }, ["text"], { spends: true }),
+    operation("table_action_items.resolve", "/api/cli/table-action-items/{item_id}/resolve", "POST", "table-actions resolve", "oxygen_table_action_item_resolve", "tables", "Record a verified uncertain Table action outcome; never repeats the external action.", { outcome: enumOf(["applied", "not_applied"]), note: text(), value: { oneOf: [text(), num(), bool(), json, rows(), { type: "null" }] } }, ["outcome"]),
+    operation("table_ingestions.append", "/api/cli/table-ingestion-runs/{ingestion_run_id}/items", "POST", "table-ingestions append", "oxygen_table_ingestions_append_items", "runs", "Append bounded ingestion items to an existing run; preserves the run's approved scope.", { items: rows(), max_attempts: int({ minimum: 1 }) }, ["items"], cliOnly),
+    operation("tables.favorites.get", "/api/cli/tables/favorite", "GET", "tables favorites", "oxygen_tables_favorites", "tables", "Read this member's table and folder favorites in the active workspace. A per-member preference; free (0 credits)."),
+    operation("tables.favorite.set", "/api/cli/tables/favorite", "POST", "tables favorite", "oxygen_tables_favorite", "tables", "Star or unstar exactly one table or folder in the active workspace. Free (0 credits); reads back the saved per-member preference.", { table: text("Table id or slug. Pass exactly one of table or folder."), folder: text("Folder id or slug. Pass exactly one of table or folder."), favorite: bool({ description: "true stars; false unstars. Free (0 credits); changes only this member's preference." }) }, ["favorite"]),
+    operation("tables.import.csv", "/api/cli/tables/import-csv", "POST", "tables import-csv", "oxygen_tables_import_csv", "tables", "Import inline CSV into a hosted Table through its durable ingestion run. Use staged upload for large files.", { csv_text: text(), csv_base64: text(), table: text(), table_name: text(), project: text(), filename: text(), upsert_key: text(), batch_size: int({ minimum: 1, maximum: 5000 }) }, [], cliOnly),
+    operation("tables.import.prepare", "/api/cli/tables/import-url", "POST", "tables import-upload", "oxygen_tables_import_upload", "tables", "Prepare a scoped storage upload for a hosted Table import; uploads and imports are separate, inspectable steps.", { file_name: text(), content_type: text(), byte_length: int({ minimum: 1 }), trace_id: text(), format: enumOf(["csv", "json", "xlsx"]) }, ["file_name", "byte_length"]),
+    operation("tables.import.preview", "/api/cli/tables/import-preview", "POST", "tables import-preview", "oxygen_tables_import_preview", "tables", "Preview a staged file's headers, rows and existing-table mapping; writes no imported rows.", { storage_key: text(), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), byte_length: int({ minimum: 1 }), table: text(), upsert_key: text() }, ["storage_key", "byte_length"], { mutates: false }),
+    operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
+    operation("tables.import.file", "/api/cli/tables/import-file", "POST", "tables import-file", "oxygen_tables_import_file", "tables", "Import small base64 file bytes through the shared multipart import API; use staged upload for large files.", { content_base64: text(), file_name: text(), content_type: text(), table: text(), table_name: text(), project: text(), format: enumOf(["csv", "json", "xlsx"]), sheet: text(), upsert_key: text(), source_key_map: json, source_hash: text(), batch_size: int({ minimum: 1, maximum: 5000 }), max_concurrency: int({ minimum: 1 }) }, ["content_base64", "file_name"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
+    operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Preview which columns can link two Tables and how many rows match; creates no relation.", { table: text(), to: text(), on: text(), scan_limit: int({ minimum: 1 }) }, ["table", "to"], { mutates: false }),
+    operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Recover bounded pending cells in one Table through the platform's native recovery path.", { table: text(), max_items: int({ minimum: 1 }) }, ["table"], mcpOnly),
+    operation("tables.webhooks.create", "/api/cli/tables/webhooks", "POST", "tables webhook create", "oxygen_table_webhook_create", "tables", "Create an inbound Table webhook or platform LinkedIn feed. Optional auto_run is standing permission with explicit or plan-default delivery ceilings.", { table: text(), name: text(), mode: enumOf(["insert", "upsert"]), upsert_key: text(), items_path: text(), event_id_path: text(), event_type_path: text(), occurred_at_path: text(), auth_mode: enumOf(["none", "secret"]), feed_kind: enumOf(["generic", "unipile"]), unipile_account_id: text(), event_types: list(), mapping: text(), auto_run: json }, ["table"], mcpOnly),
+    operation("tables.webhooks.update", "/api/cli/tables/webhooks", "PATCH", "tables webhook update", "oxygen_table_webhook_update", "tables", "Edit a Table webhook's name, state or standing auto_run; auth_mode=secret rotates its secret and returns it once.", { endpoint_id: text(), name: text(), status: enumOf(["active", "disabled"]), auth_mode: enumOf(["none", "secret"]), auto_run: json, clear_auto_run: bool() }, ["endpoint_id"], mcpOnly),
+    operation("whatsapp.draft", "/api/cli/whatsapp/draft", "POST", "whatsapp draft", "oxygen_whatsapp_draft", "inbox", "Generate a WhatsApp reply draft in the workspace voice, or approve a reviewed draft for an existing chat. Draft generation uses managed AI credits.", { conversation_id: text(), goal: text(), row_id: text(), object: text(), approved: bool(), draft_id: text(), text: text() }, ["conversation_id"], { ...cliOnly, spends: true }),
+    operation("whatsapp.drafts.list", "/api/cli/whatsapp/drafts", "GET", "whatsapp drafts list", "oxygen_whatsapp_drafts_list", "inbox", "Read the WhatsApp draft review queue.", { status: text(), limit: int({ minimum: 1 }) }, [], cliOnly),
+    operation("whatsapp.drafts.update", "/api/cli/whatsapp/drafts/update", "POST", "whatsapp drafts update", "oxygen_whatsapp_draft_update", "inbox", "Edit an open WhatsApp draft before approving or sending it.", { draft_id: text(), text: text() }, ["draft_id", "text"], cliOnly),
+    operation("whatsapp.drafts.reject", "/api/cli/whatsapp/drafts/reject", "POST", "whatsapp drafts reject", "oxygen_whatsapp_draft_reject", "inbox", "Reject an open WhatsApp draft without sending it.", { draft_id: text(), reason: text() }, ["draft_id"], cliOnly),
+    operation("worker.repair", "/api/cli/worker/repair", "POST", "worker repair", "oxygen_workspace_queue_repair", "workspace", "Repair this workspace's stalled execution queues through the native bounded recovery path.", {}, [], mcpOnly),
+    operation("db.status", "/api/cli/db/status", "GET", "db status", "oxygen_workspace_database_status", "workspace", "Read this workspace's database status and latest completed provisioning/migration receipt; not a list of current pending migrations. Historical Neon fields are lineage. Hosting is plan-included; 0 credits.", {}, [], mcpOnly),
+    operation("db.provision", "/api/cli/db/provision", "POST", "db provision", "oxygen_workspace_database_provision", "workspace", "Provision or retry this workspace database immediately; already-ready workspaces retain it. No preview or confirmation field; native workspace write access applies. May outlast the connector deadline: read oxygen_workspace_database_status before retrying. Hosting is plan-included; 0 credits.", {}, [], mcpOnly),
+    operation("sessions.list", "/api/cli/sessions", "GET", "sessions list", "oxygen_sessions_list", "workspace", "List your personal CLI sessions across workspaces; OAuth or personal user session required, organization API keys are refused."),
+    operation("sessions.revoke", "/api/cli/sessions/{session_id}", "DELETE", "sessions revoke", "oxygen_sessions_revoke", "workspace", "Revoke one of your personal CLI sessions; OAuth or personal user session required, organization API keys are refused."),
+    operation("billing.allowance", "/api/cli/billing/allowance", "GET", "billing allowance", "oxygen_billing_allowance", "billing", "Read this workspace's current recurring credit allowance and period.", {}, [], mcpOnly),
+    operation("billing.invoices", "/api/cli/billing/invoices", "GET", "billing invoices", "oxygen_billing_invoices", "billing", "Read this workspace's billing invoices and their hosted payment links.", {}, [], mcpOnly),
+    operation("billing.seats.set", "/api/cli/billing/seats", "POST", "billing seats set", "oxygen_billing_seats_set", "billing", "Set purchased legacy sending-seat quantity. Retired seats cannot increase; reducing existing seats lowers the next renewal charge.", { seat_key: enumOf(["linkedin", "whatsapp", "phone_number", "email_sender"]), quantity: int({ minimum: 0 }) }, ["seat_key", "quantity"], mcpOnly),
+    operation("collaboration.gates.list", "/api/cli/collab/gates", "GET", "approvals gate list", "oxygen_approval_gates_list", "collaboration", "Read this workspace's approval gates, optionally for one exact subject.", { subject: text() }, [], mcpOnly),
+    operation("collaboration.members.list", "/api/cli/collab/members", "GET", "approvals client list", "oxygen_workspace_members_list", "collaboration", "Read workspace members and their collaboration roles.", {}, [], mcpOnly),
+    operation("crm.connections", "/api/cli/crm/objects/{object}/records/{row_id}/connections", "GET", "crm connections", "oxygen_crm_connections", "crm", "Read a CRM record's connected conversations, sequence enrollments and related activity.", { conversation_limit: int({ minimum: 1 }), sequence_limit: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("crm.tasks.list", "/api/cli/crm/tasks", "GET", "crm tasks list", "oxygen_crm_tasks_queue", "crm", "Read the workspace task queue by status, assignee and cursor.", { status: text(), assignee: text(), cursor: text(), limit: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("crm.files.download", "/api/cli/crm/files/{attachment_id}/download", "GET", "crm files download", "oxygen_crm_file_download", "crm", "Download a tenant-owned record attachment by attachment_id. The native authenticated response contains its exact bytes.", {}, [], { binary: { maxBytes: 50 * 1024 * 1024 } }),
+    operation("db.cost_policy.get", "/api/cli/db/cost-policy", "GET", "db cost-policy", "oxygen_database_cost_policy", "workspace", "Read this workspace's retired Neon cost-policy status. PostgreSQL has no per-workspace sleep control; stored Neon policy is historical. 0 credits.", {}, [], mcpOnly),
+    operation("egress.dedicated.get", "/api/cli/egress/dedicated", "GET", "egress dedicated status", "oxygen_dedicated_egress_status", "deliverability", "Read dedicated outbound egress status and its current monthly commitment without activating it.", {}, [], mcpOnly),
+    operation("knowledge.files.list", "/api/cli/knowledge/files/list", "GET", "knowledge files list", "oxygen_knowledge_files_list", "knowledge", "List files in one entitled Knowledge repository mount; returns metadata and a bounded cursor.", { mountId: text(), cursor: text(), limit: int({ minimum: 1 }) }, ["mountId"], mcpOnly),
+    operation("knowledge.files.get", "/api/cli/knowledge/files/get", "GET", "knowledge files get", "oxygen_knowledge_file_get", "knowledge", "Read one entitled Knowledge file's metadata and bounded text when supported; revision pins historical content.", { id: text(), revision: int({ minimum: 1 }) }, ["id"], mcpOnly),
+    operation("knowledge.files.download", "/api/cli/knowledge/files/download", "GET", "knowledge files download", "oxygen_knowledge_file_download", "knowledge", "Download exact bytes for one entitled Knowledge file or pinned revision.", { id: text(), revision: int({ minimum: 1 }) }, ["id"], { ...mcpOnly, binary: { maxBytes: 50 * 1024 * 1024 } }),
+    operation("mailboxes.sequences", "/api/cli/mailboxes/{mailbox_id}/sequences", "GET", "mailboxes sequences", "oxygen_mailbox_sequences", "deliverability", "Read the sequences using one sending mailbox by id or email address."),
+    operation("managed_inboxes.registrant", "/api/cli/managed-inboxes/registrant", "GET", "managed-inboxes registrant", "oxygen_managed_inbox_registrant", "deliverability", "Read this workspace's domain-registration contact.", {}, [], mcpOnly),
+    operation("orgs.billing_owners", "/api/cli/orgs/billing-owners", "GET", "orgs billing-owners", "oxygen_workspace_billing_owners", "workspace", "Read eligible billing-owner workspaces from the caller's memberships.", {}, [], mcpOnly),
+    operation("search.runs.items", "/api/cli/search/runs/{search_run_id}/items", "GET", "search runs items", "oxygen_search_run_items", "enrichment", "Read durable search ingestion items by run id and optional status.", { status: text(), limit: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("senders.checkpoints", "/api/cli/senders/checkpoints", "GET", "senders checkpoints", "oxygen_sender_checkpoints", "sequences", "Read connected sender authentication checkpoints that need human completion.", {}, [], mcpOnly),
+    operation("suppressions.domains.list", "/api/cli/suppressions/domains", "GET", "suppressions domains", "oxygen_suppressed_domains_list", "sequences", "Read domain-wide email suppressions with reason, search and pagination.", { reason: text(), search: text(), limit: int({ minimum: 1 }), offset: int({ minimum: 0 }) }, [], mcpOnly),
+    operation("suppressions.domains.remove", "/api/cli/suppressions/domains", "DELETE", "suppressions remove-domain", "oxygen_suppressed_domains_remove", "sequences", "Remove one domain-wide email suppression, or exact domains in bulk. This does not resume enrollments automatically.", { domain: text(), domains: list() }, [], mcpOnly),
+    operation("suppressions.addresses.remove", "/api/cli/suppressions/addresses", "DELETE", "suppressions remove-address", "oxygen_suppressed_addresses_remove", "sequences", "Remove one email-address suppression, or exact emails in bulk. This does not resume enrollments automatically.", { email: text(), emails: list() }, [], mcpOnly),
+    operation("table_action_runs.list", "/api/cli/table-action-runs", "GET", "table-runs list", "oxygen_table_action_runs_list", "runs", "Read durable Table action runs, optionally filtered by status or trace.", { table: text(), status: text(), trace_id: text(), limit: int({ minimum: 1 }) }, ["table"], mcpOnly),
+    operation("tables.columns.fields", "/api/cli/tables/columns/fields", "GET", "columns fields", "oxygen_table_column_fields", "tables", "Read the output fields available from one hosted Table column.", { table: text(), column: text() }, ["table", "column"], mcpOnly),
+    operation("tools.favorites", "/api/cli/tools/favorites", "GET", "tools favorites", "oxygen_tool_favorites", "enrichment", "Read this member's favorite tool catalog entries in the active workspace.", {}, [], mcpOnly),
+    operation("tools.check_access", "/api/cli/tools/check-access", "POST", "tools check-access", "oxygen_tools_check_access", "enrichment", "Read tool access for this workspace; verify_credential explicitly opts into a provider credential probe.", { tool_id: text(), connection_id: text(), credential_mode: enumOf(["managed", "user_api_key"]), input: json, verify_credential: bool() }, ["tool_id"], { ...cliOnly, mutates: false }),
+    operation("linkedin.connections.import_status", "/api/cli/linkedin/connections/import", "GET", "linkedin connections import-status", "oxygen_linkedin_connections_import_status", "sequences", "Read the durable LinkedIn connections import status and target Table.", { account: text() }),
+    operation("linkedin.followers.import_status", "/api/cli/linkedin/followers/import", "GET", "linkedin followers import-status", "oxygen_linkedin_followers_import_status", "sequences", "Read the durable LinkedIn followers import status and target Table.", { account: text() }),
+    operation("linkedin.inbox.backfill_status", "/api/cli/linkedin/inbox/backfill", "GET", "linkedin inbox backfill-status", "oxygen_linkedin_inbox_backfill_status", "inbox", "Read the durable LinkedIn inbox backfill status.", { account: text() }),
+    operation("linkedin.viewers.list", "/api/cli/linkedin/viewers", "GET", "linkedin viewers list", "oxygen_profile_viewers", "publishing", "Read named LinkedIn profile viewers, respecting the connected account's privacy ceiling.", { account: text(), start: int({ minimum: 0 }), include_raw: bool() }, [], cliOnly),
+    operation("signals.search.filters", "/api/cli/signals/search/preview", "GET", "signals search filters", "oxygen_signals_search_preview", "signals", "Read the LinkedIn post-search filter catalog and credential status; runs no search.", { source: enumOf(["linkedin_posts"]) }, [], cliOnly),
+    operation("visuals.download", "/api/cli/visuals/files/{file_id}/download", "GET", "visuals download", "oxygen_visual_file_download", "publishing", "Download a tenant-owned visual source or rendered file as exact bytes.", {}, [], { ...mcpOnly, binary: { maxBytes: 50 * 1024 * 1024 } }),
+    operation("workflows.mcp_callable", "/api/cli/workflows/mcp-callable", "GET", "workflows mcp list", "oxygen_workflows_mcp_callable", "workflows", "List this workspace's published MCP-callable Workflow definitions and interfaces.", {}, [], mcpOnly),
+    operation("skills.get", "/api/cli/skills/get", "GET", "skills get", "oxygen_skills_get", "workspace", "Read one authenticated, entitled product-skill entrypoint or manifest-listed supporting file.", { name: text(), file: text("Relative supporting-file path from the manifest; omit for SKILL.md.") }, ["name"], mcpOnly),
+];

package/node_modules/@oxygen/shared/dist/contracts/dashboard-tabs.d.ts

@@ -0,0 +1,3 @@
+export declare const DASHBOARD_TAB_CREATE_CONTRACT: import("./schema.js").ContractObject<{
+    readonly title: import("./schema.js").StringProperty;
+}, "title">;

package/node_modules/@oxygen/shared/dist/contracts/dashboard-tabs.js

@@ -0,0 +1,2 @@
+import { obj, str } from "./schema.js";
+export const DASHBOARD_TAB_CREATE_CONTRACT = obj({ title: str({ minLength: 1, description: "Tab title." }) }, { required: ["title"] });

package/node_modules/@oxygen/shared/dist/contracts/database.d.ts

@@ -0,0 +1,30 @@
+import { type ContractObject } from "./schema.js";
+export declare const DATABASE_DEFAULT_MAX_ROWS = 100;
+export declare const DATABASE_HARD_MAX_ROWS = 1000;
+export declare const DATABASE_HARD_MAX_CHARS = 48000;
+export declare function normalizeDatabaseMaxRows(value?: number): number;
+export declare const DATABASE_ATTACH_CONTRACT: ContractObject<{
+    readonly database_url: import("./schema.js").StringProperty;
+}, "database_url">;
+export declare const DATABASE_MIGRATE_CONTRACT: ContractObject<{
+    readonly rotate_credentials: import("./schema.js").BooleanProperty;
+}, never>;
+export declare const DATABASE_QUERY_CONTRACT: ContractObject<{
+    readonly sql: import("./schema.js").StringProperty;
+    readonly max_rows: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, "sql">;
+/** Normalize existing route aliases/coercions first; ignored fields stay compatible. */
+export declare function validateDatabaseInput(contract: ContractObject, input: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@oxygen/shared/dist/contracts/database.js

@@ -0,0 +1,29 @@
+/** Customer database fields; fleet repair stays on its existing staff routes. */
+import { OxygenError } from "../cli-result.js";
+import { bool, int, obj, str, validateContract } from "./schema.js";
+export const DATABASE_DEFAULT_MAX_ROWS = 100;
+export const DATABASE_HARD_MAX_ROWS = 1_000;
+export const DATABASE_HARD_MAX_CHARS = 48_000;
+export function normalizeDatabaseMaxRows(value) {
+    return value === undefined || !Number.isFinite(value)
+        ? DATABASE_DEFAULT_MAX_ROWS
+        : Math.max(1, Math.min(Math.trunc(value), DATABASE_HARD_MAX_ROWS));
+}
+export const DATABASE_ATTACH_CONTRACT = obj({
+    database_url: str({ minLength: 1, description: "Owner PostgreSQL URL for a database you own; attaches and initializes it immediately." }),
+}, { required: ["database_url"] });
+export const DATABASE_MIGRATE_CONTRACT = obj({
+    rotate_credentials: bool({ description: "Repair runtime/read passwords and stored credentials. Omitted/false keeps them; routine migrations do not need rotation." }),
+});
+export const DATABASE_QUERY_CONTRACT = obj({
+    sql: str({ minLength: 1, description: "One SELECT, WITH or EXPLAIN statement; read-only transaction, dedicated customer login, default 5-second timeout." }),
+    max_rows: int({ minimum: 1, maximum: DATABASE_HARD_MAX_ROWS, clamp: true, description: "CLI/API default 100; MCP default 20; hard cap 1000." }),
+    max_chars: int({ minimum: 1_000, maximum: DATABASE_HARD_MAX_CHARS, description: "Optional complete-row response window including metadata. MCP caps at 10000 chars, built-in agents 4000. Narrow SELECT if one row cannot fit." }),
+}, { required: ["sql"] });
+/** Normalize existing route aliases/coercions first; ignored fields stay compatible. */
+export function validateDatabaseInput(contract, input) {
+    const result = validateContract(contract, input, { unknown: "warn", overMax: "reject" });
+    if (!result.ok)
+        throw new OxygenError("invalid_request", "Invalid workspace database request.", { details: { issues: result.issues }, exitCode: 1 });
+    return result.value;
+}

package/node_modules/@oxygen/shared/dist/contracts/integration-connect.d.ts

@@ -0,0 +1,4 @@
+/** Account selection is shared; the remaining provider-specific connect fields have separate owners. */
+export declare const INTEGRATION_CONNECT_ACCOUNT_CONTRACT: import("./schema.js").ContractObject<{
+    readonly account_id: import("./schema.js").StringProperty;
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/integration-connect.js

@@ -0,0 +1,7 @@
+import { obj, str } from "./schema.js";
+/** Account selection is shared; the remaining provider-specific connect fields have separate owners. */
+export const INTEGRATION_CONNECT_ACCOUNT_CONTRACT = obj({
+    account_id: str({
+        description: "Cloudflare account id from needs_account_selection. Omit for a single-account token.",
+    }),
+});

package/node_modules/@oxygen/shared/dist/contracts/knowledge-content-reads.d.ts

@@ -0,0 +1,43 @@
+export declare const knowledgeIndexReadContract: import("./schema.js").ContractObject<{
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const knowledgePageReadContract: import("./schema.js").ContractObject<{
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly slug: import("./schema.js").StringProperty;
+    readonly id: import("./schema.js").StringProperty;
+    readonly view: {
+        type: "string";
+        enum: readonly ("body" | "data" | "data_keys" | "full" | "links" | "metadata" | "sources")[];
+        description?: string;
+    };
+    readonly revision: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly include_links: import("./schema.js").BooleanProperty;
+    readonly path: import("./schema.js").StringProperty;
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/knowledge-content-reads.js

@@ -0,0 +1,20 @@
+import { KNOWLEDGE_SLUG_MAX_LENGTH } from "../knowledge-constants.js";
+import { bool, enumOf, int, obj, str } from "./schema.js";
+// Optional native windows: unqualified HTTP/CLI reads retain their legacy shape.
+const window = {
+    cursor: str({ minLength: 1, maxLength: 4096 }),
+    max_chars: int({ minimum: 2000, maximum: 48000, description: "Complete receipt window; surface cap applies." }),
+};
+export const knowledgeIndexReadContract = obj({
+    limit: int({ minimum: 1, maximum: 1000 }),
+    ...window,
+});
+export const knowledgePageReadContract = obj({
+    slug: str({ minLength: 1, maxLength: KNOWLEDGE_SLUG_MAX_LENGTH }),
+    id: str({ minLength: 1 }),
+    view: enumOf(["metadata", "body", "data", "data_keys", "links", "sources", "full"]),
+    revision: int({ minimum: 1 }),
+    include_links: bool({ description: "Full only; default true." }),
+    path: str({ maxLength: 1024, description: "JSON pointer; data/data_keys/sources." }),
+    ...window,
+});

package/node_modules/@oxygen/shared/dist/contracts/linkedin-invites-list.d.ts

@@ -0,0 +1,12 @@
+export declare const LINKEDIN_SENT_INVITES_MAX_LIMIT = 200;
+export declare const LINKEDIN_SENT_INVITES_QUERY_CONTRACT: import("./schema.js").ContractObject<{
+    readonly account: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly cursor: import("./schema.js").StringProperty;
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/linkedin-invites-list.js

@@ -0,0 +1,8 @@
+/** Exact selectors for one native/provider sent-invitation page. */
+import { int, obj, str } from "./schema.js";
+export const LINKEDIN_SENT_INVITES_MAX_LIMIT = 200;
+export const LINKEDIN_SENT_INVITES_QUERY_CONTRACT = obj({
+    account: str({ description: "Sender id, connection id, or Unipile account id." }),
+    limit: int({ minimum: 1, description: "Maximum invitations to return." }),
+    cursor: str({ description: "Pagination cursor from a previous response." }),
+});

package/node_modules/@oxygen/shared/dist/contracts/operations.d.ts

@@ -1,13 +1,41 @@
-import type { ContractObject } from "./schema.js";
+import { type ContractObject } from "./schema.js";
 export type OperationSpec<C extends ContractObject = ContractObject> = {
     /** Stable id, `<resource>.<verb>`. */
     id: string;
     /** Route template; `{name}` segments are path parameters. */
     route: string;
-    method: "POST" | "PATCH";
+    method: "GET" | "POST" | "PATCH" | "DELETE";
     /** When set, the contract describes `body[bodyKey]` rather than the whole body. */
     bodyKey?: string;
     contract: C;
+    /** Named route parameters, exposed as exact flags/properties by generated surfaces. */
+    parameters?: readonly string[];
+    /** Fields sent in the query rather than the JSON body (all fields for GET). */
+    queryFields?: readonly string[];
+    /** Array fields encoded as repeated query keys rather than a JSON string. */
+    repeatedQueryFields?: readonly string[];
+    /** Fixed discriminator fields owned by this operation, never supplied by a caller. */
+    defaults?: Readonly<Record<string, unknown>>;
+    /** A side already has a manual, domain-native implementation. */
+    generated?: {
+        cli: boolean;
+        mcp: boolean;
+    };
+    /** Multipart transport for an operation whose API takes one uploaded file. */
+    multipart?: {
+        contentField: string;
+        nameField: string;
+        typeField: string;
+        fileField: string;
+    };
+    /** Download bytes through the same authenticated route; never follow redirects. */
+    binary?: {
+        maxBytes: number;
+        stream?: never;
+    } | {
+        stream: true;
+        resourceParameter: string;
+    };
     cli: {
         /** Command words after `oxygen`, e.g. `["senders", "limits", "set"]`. */
         path: readonly string[];
@@ -24,10 +52,28 @@ export type OperationSpec<C extends ContractObject = ContractObject> = {
         description: string;
         /** The MCP toolset domain (pack) the tool registers under. */
         pack: string;
+        /** Source-reviewed effect hints; never an authorization bypass. */
+        annotations?: {
+            destructiveHint?: boolean;
+            openWorldHint?: boolean;
+            idempotentHint?: boolean;
+        };
     };
     mutates: boolean;
     spends: boolean;
 };
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export declare function operationPath(spec: Pick<OperationSpec, "route">, params: Readonly<Record<string, string>>): string;
+/** The exact public grammar, including the operation's scoped route parameters. */
+export declare function operationInputContract(spec: OperationSpec): ContractObject;
+/** Preserve absent, false, null and empty values while assigning each field to its transport. */
+export declare function operationRequest(spec: OperationSpec, args: Record<string, unknown>): {
+    path: string;
+    method: OperationSpec["method"];
+    body?: Record<string, unknown>;
+};
+/** Decode the explicit file property and keep the native multipart API contract. */
+export declare function operationFormData(spec: OperationSpec, body: Record<string, unknown>): FormData;
 export declare const OPERATION_SPECS: readonly OperationSpec[];
+export declare const CLI_OPERATIONS: OperationSpec[];
+export declare const MCP_OPERATIONS: OperationSpec[];

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -4,8 +4,12 @@
  * The CLI command, the MCP tool and the route read the same spec, so the three
  * cannot disagree on which fields exist. Leaf and browser-safe.
  */
-import { CONNECTOR_UPDATE_OPERATION } from "./connectors.js";
+import { CONNECTOR_EVENTS_REVOKE_OPERATION, CONNECTOR_UPDATE_OPERATION } from "./connectors.js";
+import { str } from "./schema.js";
 import { SENDER_LIMITS_SET_OPERATION } from "./sender-limits.js";
+import { WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION } from "./workspace-pages.js";
+import { BROWSER_OPERATIONS } from "./browser-operations.js";
+import { CUSTOMER_OPERATIONS } from "./customer-operations.js";
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export function operationPath(spec, params) {
     return spec.route.replace(/\{(\w+)\}/g, (_match, name) => {
@@ -15,4 +19,66 @@ export function operationPath(spec, params) {
         return encodeURIComponent(value);
     });
 }
-export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION];
+/** The exact public grammar, including the operation's scoped route parameters. */
+export function operationInputContract(spec) {
+    const parameters = spec.parameters ?? [];
+    for (const name of parameters) {
+        if (Object.hasOwn(spec.contract.properties, name))
+            throw new Error(`Operation ${spec.id} uses ${name} for both a route parameter and a body field.`);
+    }
+    return {
+        ...spec.contract,
+        properties: {
+            ...Object.fromEntries(parameters.map((name) => [name, str({ minLength: 1 })])),
+            ...spec.contract.properties,
+        },
+        required: [...parameters, ...(spec.contract.required ?? [])],
+    };
+}
+/** Preserve absent, false, null and empty values while assigning each field to its transport. */
+export function operationRequest(spec, args) {
+    const params = Object.fromEntries((spec.parameters ?? []).map((name) => [name, String(args[name] ?? "")]));
+    let path = operationPath(spec, params);
+    const body = { ...spec.defaults };
+    const query = new URLSearchParams();
+    for (const name of Object.keys(spec.contract.properties)) {
+        const value = args[name];
+        if (value === undefined)
+            continue;
+        if (spec.method === "GET" || spec.queryFields?.includes(name)) {
+            if (spec.repeatedQueryFields?.includes(name) && Array.isArray(value)) {
+                for (const entry of value)
+                    query.append(name, String(entry));
+            }
+            else if (value !== null)
+                query.set(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+        }
+        else
+            body[name] = value;
+    }
+    if (query.size)
+        path += `?${query}`;
+    return { path, method: spec.method, ...(spec.method !== "GET" && Object.keys(body).length > 0 ? { body: spec.bodyKey ? { [spec.bodyKey]: body } : body } : {}) };
+}
+/** Decode the explicit file property and keep the native multipart API contract. */
+export function operationFormData(spec, body) {
+    const fields = spec.multipart;
+    if (!fields)
+        throw new Error("This operation does not accept a file.");
+    const encoded = body[fields.contentField];
+    if (typeof encoded !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded) || !encoded) {
+        throw new Error(`${fields.contentField} must contain valid non-empty base64 file bytes.`);
+    }
+    const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+    const form = new FormData();
+    form.set(fields.fileField, new Blob([bytes], { type: String(body[fields.typeField] ?? "application/octet-stream") }), String(body[fields.nameField] ?? "upload"));
+    for (const [key, value] of Object.entries(body)) {
+        if ([fields.contentField, fields.nameField, fields.typeField].includes(key) || value === undefined)
+            continue;
+        form.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+    }
+    return form;
+}
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS];
+export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
+export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);

package/node_modules/@oxygen/shared/dist/contracts/table-grid-query.d.ts

@@ -0,0 +1,4 @@
+export declare const TABLE_GRID_QUERY_OPTIONS_CONTRACT: import("./schema.js").ContractObject<{
+    readonly include_stats: import("./schema.js").BooleanProperty;
+    readonly include_fill: import("./schema.js").BooleanProperty;
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/table-grid-query.js

@@ -0,0 +1,6 @@
+/** Optional first-page metadata on the shared Table grid query. */
+import { bool, obj } from "./schema.js";
+export const TABLE_GRID_QUERY_OPTIONS_CONTRACT = obj({
+    include_stats: bool({ description: "With --format grid, include column fill statistics and their table row count when available; 0 credits." }),
+    include_fill: bool({ description: "With --format grid, include fill progress on an empty first page when available; ignored on cursor pages. 0 credits." }),
+});

package/node_modules/@oxygen/shared/dist/contracts/table-query-grid.d.ts

@@ -0,0 +1,21 @@
+/** Optional representation of Query; canonical raw rows remain the default. */
+export declare const TABLE_QUERY_GRID_CONTRACT: import("./schema.js").ContractObject<{
+    readonly format: {
+        type: "string";
+        enum: readonly "grid"[];
+        description?: string;
+    };
+    readonly include_stats: import("./schema.js").BooleanProperty;
+    readonly include_fill: import("./schema.js").BooleanProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const TABLE_QUERY_GRID_NATIVE_WINDOW = 10000;
+export declare const TABLE_QUERY_GRID_BUILTIN_WINDOW = 4000;
+/** Measure the complete native receipt and the escaped built-in host receipt. */
+export declare function tableQueryGridResultFits(data: Record<string, unknown>, maxChars: number | undefined, surface: string | null): boolean;

package/node_modules/@oxygen/shared/dist/contracts/table-query-grid.js

@@ -0,0 +1,27 @@
+import { success } from "../cli-result.js";
+import { OXYGEN_VERSION } from "../version.js";
+import { bool, enumOf, int, obj } from "./schema.js";
+/** Optional representation of Query; canonical raw rows remain the default. */
+export const TABLE_QUERY_GRID_CONTRACT = obj({
+    format: enumOf(["grid"], { description: "Grid cell previews." }),
+    include_stats: bool({ description: "Optional column stats." }),
+    include_fill: bool({ description: "Empty first-page fill state." }),
+    max_chars: int({ minimum: 1_000, maximum: 100_000, description: "Complete grid envelope chars." }),
+});
+export const TABLE_QUERY_GRID_NATIVE_WINDOW = 10_000;
+// Deliberately below Strands' shipped 6000 default; counts the complete host
+// object rather than only its text. This changes no adapter's outer ceiling.
+export const TABLE_QUERY_GRID_BUILTIN_WINDOW = 4_000;
+/** Measure the complete native receipt and the escaped built-in host receipt. */
+export function tableQueryGridResultFits(data, maxChars, surface) {
+    if (maxChars === undefined)
+        return true;
+    if (JSON.stringify(success("tables query", data)).length > maxChars)
+        return false;
+    if (surface === "agent" || surface === "copilot") {
+        return JSON.stringify({
+            ok: true, text: JSON.stringify(data), structured: { ...data, oxygen_version: OXYGEN_VERSION },
+        }).length <= TABLE_QUERY_GRID_BUILTIN_WINDOW;
+    }
+    return true;
+}

package/node_modules/@oxygen/shared/dist/contracts/tool-catalog-detail.d.ts

@@ -0,0 +1,19 @@
+import { type Infer } from "./schema.js";
+/** Explicit metadata projections; omitted native HTTP/CLI options retain full detail. */
+export declare const toolCatalogDetailQueryContract: import("./schema.js").ContractObject<{
+    readonly view: {
+        type: "string";
+        enum: readonly ("access" | "examples" | "field_names" | "full" | "guidance" | "input_schema" | "native_fields" | "output_schema" | "pricing" | "summary")[];
+        description?: string;
+    };
+    readonly field_keys: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    readonly field_query: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export type ToolCatalogDetailQuery = Infer<typeof toolCatalogDetailQueryContract>;