@oxygen-agent/cli 1.1011.493 → 1.1011.600

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

@@ -1,6 +1,9 @@
 /** 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";
+import { WHATSAPP_DRAFTS_READ_CONTRACT } from "./whatsapp-reads.js";
+import { BILLING_OWNER_READ_CONTRACT } from "./billing-owner-read.js";
+import { COPILOT_SESSIONS_LIST_CONTRACT } from "./copilot-sessions.js";
 const text = (description) => str(description === undefined ? {} : { description });
 const list = () => arr(str());
 const json = { type: "object", additionalProperties: true };
@@ -28,7 +31,7 @@ export const CUSTOMER_OPERATIONS = [
     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.list", "/api/cli/copilot/sessions", "GET", "copilot list", "oxygen_copilot_sessions_list", "agents", "List attended Copilot sessions in this workspace.", COPILOT_SESSIONS_LIST_CONTRACT.properties, [], 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"]),
@@ -87,7 +90,7 @@ export const CUSTOMER_OPERATIONS = [
     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.list", "/api/cli/whatsapp/drafts", "GET", "whatsapp drafts list", "oxygen_whatsapp_drafts_list", "inbox", "Read stored WhatsApp agent drafts; personal composer drafts stay private. Use summary and exact draft_id/value for long content.", WHATSAPP_DRAFTS_READ_CONTRACT.properties, [], 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),
@@ -110,7 +113,7 @@ export const CUSTOMER_OPERATIONS = [
     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("orgs.billing_owners", "/api/cli/orgs/billing-owners", "GET", "orgs billing-owners", "oxygen_workspace_billing_owners", "workspace", "Read the current workspace's billing owner, entitlement and payer candidates, including ineligibility reasons. Optional organization asserts the current workspace. Free.", BILLING_OWNER_READ_CONTRACT.properties, [], 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),

package/node_modules/@oxygen/shared/dist/contracts/function-library-read.d.ts

@@ -0,0 +1,14 @@
+export declare const FUNCTION_LIBRARY_FILTER: {
+    readonly all: "all";
+    readonly managed: "managed";
+    readonly favorites: "favorites";
+};
+export declare const FUNCTION_LIBRARY_FILTERS: readonly ["all", "managed", "favorites"];
+export type FunctionLibraryFilter = (typeof FUNCTION_LIBRARY_FILTERS)[number];
+export declare const FUNCTION_LIBRARY_LIST_READ_CONTRACT: import("./schema.js").ContractObject<{
+    readonly filter: {
+        type: "string";
+        enum: readonly ("all" | "favorites" | "managed")[];
+        description?: string;
+    };
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/function-library-read.js

@@ -0,0 +1,16 @@
+import { enumOf, obj } from "./schema.js";
+export const FUNCTION_LIBRARY_FILTER = {
+    all: "all",
+    managed: "managed",
+    favorites: "favorites",
+};
+export const FUNCTION_LIBRARY_FILTERS = [
+    FUNCTION_LIBRARY_FILTER.all,
+    FUNCTION_LIBRARY_FILTER.managed,
+    FUNCTION_LIBRARY_FILTER.favorites,
+];
+export const FUNCTION_LIBRARY_LIST_READ_CONTRACT = obj({
+    filter: enumOf(FUNCTION_LIBRARY_FILTERS, {
+        description: "list_functions: all (default), favorites, or retired managed (empty).",
+    }),
+});

package/node_modules/@oxygen/shared/dist/contracts/inbox-drafts-read.d.ts

@@ -0,0 +1,45 @@
+export declare const INBOX_DRAFT_STATUSES: readonly ["queued", "edited", "approved", "sent", "rejected"];
+export declare const INBOX_DRAFT_CHANNELS: readonly ["email", "linkedin"];
+export declare const INBOX_DRAFTS_READ_CONTRACT: import("./schema.js").ContractObject<{
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary" | "value")[];
+        description?: string;
+    };
+    readonly path: import("./schema.js").StringProperty;
+    readonly value_cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly status: import("./schema.js").StringProperty;
+    readonly channel: {
+        type: "string";
+        enum: readonly ("email" | "linkedin")[];
+        description?: string;
+    };
+    readonly sequence_id: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly conversation_id: import("./schema.js").StringProperty;
+    readonly offset: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly draft_id: import("./schema.js").StringProperty;
+}, never>;
+/** PostgreSQL's UUID input accepts braces and optional hyphens after groups of
+ * four hex digits. Validate without normalizing: LinkedIn's text comparison
+ * and the native SQL UUID comparison retain their shipped semantics. */
+export declare function isInboxDraftUuid(value: string): boolean;

package/node_modules/@oxygen/shared/dist/contracts/inbox-drafts-read.js

@@ -0,0 +1,21 @@
+import { enumOf, int, obj, str } from "./schema.js";
+import { STORED_READ_WINDOW_FIELDS } from "./stored-read-window.js";
+export const INBOX_DRAFT_STATUSES = ["queued", "edited", "approved", "sent", "rejected"];
+export const INBOX_DRAFT_CHANNELS = ["email", "linkedin"];
+export const INBOX_DRAFTS_READ_CONTRACT = obj({
+    status: str({ description: "Comma-separated draft statuses (queued,edited,approved,sent,rejected)." }),
+    channel: enumOf(INBOX_DRAFT_CHANNELS, { description: "Filter to one channel (email | linkedin); omit for both." }),
+    sequence_id: str({ description: "Filter to one campaign (sequence) id (email drafts only)." }),
+    limit: int({ minimum: 1, maximum: 200 }),
+    conversation_id: str({ description: "Local email or LinkedIn conversation UUID. Never a provider chat id." }),
+    offset: int({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: "Skip this many matching drafts; default 0. Live queue changes may shift offsets." }),
+    draft_id: str({ description: "Exact eligible agent draft UUID, with all other queue filters still applied. Use for stable value selection." }),
+    ...STORED_READ_WINDOW_FIELDS,
+});
+/** PostgreSQL's UUID input accepts braces and optional hyphens after groups of
+ * four hex digits. Validate without normalizing: LinkedIn's text comparison
+ * and the native SQL UUID comparison retain their shipped semantics. */
+export function isInboxDraftUuid(value) {
+    const unwrapped = value.startsWith("{") && value.endsWith("}") ? value.slice(1, -1) : value;
+    return /^(?:[0-9a-f]{4}-?){7}[0-9a-f]{4}$/i.test(unwrapped);
+}

package/node_modules/@oxygen/shared/dist/contracts/limits-read.d.ts

@@ -0,0 +1,29 @@
+export declare const LIMITS_READ_SECTIONS: readonly ["summary", "capacity", "plan", "pricing", "api", "webhooks", "spend", "sending", "workflow", "all"];
+export type LimitsReadSection = typeof LIMITS_READ_SECTIONS[number];
+export declare const LIMITS_READ_QUERY_CONTRACT: import("./schema.js").ContractObject<{
+    readonly section: {
+        type: "string";
+        enum: readonly ("all" | "api" | "capacity" | "plan" | "pricing" | "sending" | "spend" | "summary" | "webhooks" | "workflow")[];
+        description?: string;
+    };
+    readonly band: {
+        type: "string";
+        enum: readonly ("199" | "1999" | "49" | "499" | "99" | "999" | "free")[];
+        description?: string;
+    };
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export type LimitsReadQuery = {
+    section?: LimitsReadSection;
+    band?: string;
+    max_chars?: number;
+};
+export declare function limitsReadQueryIssue(query: LimitsReadQuery): string | undefined;
+/** Legacy unqualified HTTP/CLI stays full. Native callers always select a section. */
+export declare function projectLimitsRead(data: Record<string, unknown>, query: LimitsReadQuery): Record<string, unknown>;

package/node_modules/@oxygen/shared/dist/contracts/limits-read.js

@@ -0,0 +1,121 @@
+import { enumOf, int, obj } from "./schema.js";
+export const LIMITS_READ_SECTIONS = ["summary", "capacity", "plan", "pricing", "api", "webhooks", "spend", "sending", "workflow", "all"];
+export const LIMITS_READ_QUERY_CONTRACT = obj({
+    section: enumOf(LIMITS_READ_SECTIONS, { description: "summary by default on MCP; capacity names the largest reconciled Table." }),
+    band: enumOf(["free", "49", "99", "199", "499", "999", "1999"], { description: "plan/all only; selecting a band defaults to plan." }),
+    max_chars: int({ minimum: 1000, maximum: 10000, description: "Projection character ceiling; omissions are named." }),
+});
+export function limitsReadQueryIssue(query) {
+    if (query.band && query.section && query.section !== "plan" && query.section !== "all")
+        return "band requires the plan or all section.";
+    return undefined;
+}
+const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const pick = (value, keys) => Object.fromEntries(keys.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]));
+const COMMON = ["organization_id", "plan_band", "plan_band_label", "plan_tier", "limits_tier", "source", "entitled", "shared_billing", "web_url", "deepLink"];
+const SECTION_FIELDS = { api: "api_rate_limits", webhooks: "webhook_ingress", spend: "spend_safety_defaults", sending: "sending_limits", workflow: "workflow_limits" };
+function capacityProjection(value) {
+    const capacity = record(value), usage = record(capacity.usage), reconciled = usage.row_usage_reconciled === true;
+    return {
+        ...pick(capacity, ["plan_band", "status", "effective_at", "target", "covers", "crm_records_share_table_storage", "platform_guard"]),
+        usage_status: capacity.usage_status ?? "temporarily_unavailable",
+        row_count_scope: "all_registered_workspace_tables_including_crm_and_archived_tables",
+        usage: Object.keys(usage).length ? {
+            ...usage,
+            workspace_rows: reconciled ? usage.workspace_rows ?? null : null,
+            largest_table_rows: reconciled ? usage.largest_table_rows ?? null : null,
+            largest_table: reconciled ? usage.largest_table ?? null : null,
+        } : null,
+        note: "Rows are registry counts, available only after every Table is reconciled. Database bytes combine the last measured bytes and estimated subsequent growth; the estimate flag and timestamps name that state. Object storage is separate.",
+    };
+}
+function pricingBand(value) {
+    const row = record(value);
+    return { ...pick(row, ["band", "label", "monthly_price_usd", "monthly_credits", "volume_bonus_percent", "usd_per_100_credits", "current"]),
+        storage: pick(record(row.storage), ["table_row_limit", "workspace_row_limit", "workspace_database_limit_bytes", "status", "effective_at", "target"]) };
+}
+/** Legacy unqualified HTTP/CLI stays full. Native callers always select a section. */
+export function projectLimitsRead(data, query) {
+    if (!query.section && query.max_chars === undefined && !query.band)
+        return data;
+    const section = query.section ?? (query.band ? "plan" : "all"), maxChars = query.max_chars ?? 10000;
+    const prior = record(data.projection);
+    const sameSelection = prior.section === section && (prior.band ?? null) === (query.band ?? null);
+    if (sameSelection
+        && typeof prior.max_chars === "number" && prior.max_chars <= maxChars
+        && Array.isArray(prior.omitted_fields) && JSON.stringify(data).length <= maxChars)
+        return data;
+    const bands = Array.isArray(data.plan_bands) ? data.plan_bands : [];
+    const current = bands.find(row => record(row).band === data.plan_band);
+    let selected = pick(data, COMMON);
+    if (sameSelection || section === "all")
+        selected = { ...data };
+    else if (section === "summary" || section === "capacity") {
+        selected.storage_capacity = capacityProjection(data.storage_capacity);
+        if (section === "summary" && current)
+            selected.current_plan = pricingBand(current);
+    }
+    else if (section === "plan") {
+        const band = query.band ?? String(data.plan_band ?? "");
+        selected.selected_band = band;
+        selected.plan_bands = bands.filter(row => record(row).band === band);
+    }
+    else if (section === "pricing") {
+        selected.plan_bands = bands.map(pricingBand);
+        const schedule = record(data.pricing_schedule);
+        selected.pricing_schedule = {
+            ...pick(schedule, ["effective_at", "status"]),
+            changes: Array.isArray(schedule.changes) ? schedule.changes.map(value => pick(record(value), ["key", "value_before", "value_after", "value_in_force"])) : [],
+        };
+    }
+    else
+        selected[SECTION_FIELDS[section]] = data[SECTION_FIELDS[section]];
+    if (!sameSelection && section === "all" && query.band)
+        selected.plan_bands = bands.filter(row => record(row).band === query.band);
+    // Copy before pruning: the full HTTP response and caller's source object are
+    // never mutated. Each removed field is named; there is no invented cursor.
+    const result = JSON.parse(JSON.stringify(selected));
+    const omitted = sameSelection && Array.isArray(prior.omitted_fields)
+        ? prior.omitted_fields.filter((value) => typeof value === "string") : [];
+    delete result.projection;
+    const receipt = { section, band: query.band ?? null, max_chars: maxChars, omitted_fields: omitted, truncated: omitted.length > 0, available_sections: LIMITS_READ_SECTIONS };
+    const bounded = { projection: receipt, ...result };
+    const markOmitted = (path) => {
+        // A whole omitted parent accounts for its children. Keeping every leaf
+        // after removing that parent would make the receipt itself unbounded.
+        for (let index = omitted.length - 1; index >= 0; index--)
+            if (omitted[index] === path || omitted[index].startsWith(`${path}.`))
+                omitted.splice(index, 1);
+        if (!omitted.some(parent => path.startsWith(`${parent}.`)))
+            omitted.push(path);
+        receipt.truncated = true;
+    };
+    const candidates = [];
+    const collect = (value, prefix = "") => {
+        for (const [key, child] of Object.entries(value)) {
+            const path = prefix ? `${prefix}.${key}` : key;
+            if (!prefix && (COMMON.includes(key) || key === "projection"))
+                continue;
+            if (typeof child === "string" || Array.isArray(child))
+                candidates.push({ parent: value, key, path, size: JSON.stringify(child).length });
+            else if (child && typeof child === "object")
+                collect(child, path);
+        }
+    };
+    collect(bounded);
+    for (const candidate of candidates.sort((a, b) => b.size - a.size || a.path.localeCompare(b.path))) {
+        if (JSON.stringify(bounded).length <= maxChars)
+            break;
+        delete candidate.parent[candidate.key];
+        markOmitted(candidate.path);
+    }
+    // Extremely small windows or future numeric objects may need a whole section
+    // omitted. Keep the exact receipt and workspace identity, never a false zero.
+    for (const key of Object.keys(bounded).filter(key => key !== "projection" && !COMMON.includes(key)).sort((a, b) => JSON.stringify(bounded[b]).length - JSON.stringify(bounded[a]).length)) {
+        if (JSON.stringify(bounded).length <= maxChars)
+            break;
+        delete bounded[key];
+        markOmitted(key);
+    }
+    return bounded;
+}

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

@@ -3,6 +3,6 @@ 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." }),
+    limit: int({ minimum: 1, description: "Requested page size; v2 defaults 20/caps 100; HTTP caps 200." }),
     cursor: str({ description: "Pagination cursor from a previous response." }),
 });

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

@@ -0,0 +1,18 @@
+import { type Infer } from "./schema.js";
+/** The native saved-filter/field read can charge four own-key provider fees. */
+export declare const PIPEDRIVE_CATALOG_QUERY_CONTRACT: import("./schema.js").ContractObject<{
+    readonly query: import("./schema.js").StringProperty;
+    readonly approved: import("./schema.js").BooleanProperty;
+    readonly max_credits: {
+        type: "number";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export type PipedriveCatalogQuery = Infer<typeof PIPEDRIVE_CATALOG_QUERY_CONTRACT>;
+/** Preserve the HTTP route's first-value, exact-true and numeric semantics. */
+export declare function readPipedriveCatalogQuery(params: URLSearchParams): PipedriveCatalogQuery;
+/** Forward only supplied contract fields; never infer approval or a ceiling. */
+export declare function pipedriveCatalogQueryParams(input: PipedriveCatalogQuery): URLSearchParams;

package/node_modules/@oxygen/shared/dist/contracts/pipedrive-catalog.js

@@ -0,0 +1,29 @@
+import { bool, num, obj, str, validateContract } from "./schema.js";
+/** The native saved-filter/field read can charge four own-key provider fees. */
+export const PIPEDRIVE_CATALOG_QUERY_CONTRACT = obj({
+    query: str({ description: "Optional filter-name search." }),
+    approved: bool({ description: "Approve this catalog read's BYOK fees." }),
+    max_credits: num({ minimum: 0, description: "Total credit ceiling for this read's four provider calls." }),
+});
+/** Preserve the HTTP route's first-value, exact-true and numeric semantics. */
+export function readPipedriveCatalogQuery(params) {
+    const input = {
+        query: params.get("query")?.trim().slice(0, 200) ?? "",
+        approved: params.get("approved") === "true",
+        max_credits: Number(params.get("max_credits")),
+    };
+    const result = validateContract(PIPEDRIVE_CATALOG_QUERY_CONTRACT, input, { unknown: "reject", overMax: "reject" });
+    // Malformed/negative caps historically return fee_approval_required when a
+    // fee applies, rather than a 400; pre-repricing reads still work without one.
+    return result.ok ? result.value : { ...input, max_credits: Number.NaN };
+}
+/** Forward only supplied contract fields; never infer approval or a ceiling. */
+export function pipedriveCatalogQueryParams(input) {
+    const params = new URLSearchParams();
+    for (const key of Object.keys(PIPEDRIVE_CATALOG_QUERY_CONTRACT.properties)) {
+        const value = input[key];
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}

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

@@ -0,0 +1,181 @@
+import { type ContractObject } from "./schema.js";
+export declare const PUBLISHING_POLICY_LIST_LIMIT = 200;
+export declare const PUBLISHING_ACTION_LIST_LIMIT = 500;
+export declare const PUBLISHING_NOTE_LIST_LIMIT = 500;
+export declare const PUBLISHING_REVISION_LIST_LIMIT = 200;
+export declare const PUBLISHING_METRIC_LIST_LIMIT = 400;
+export declare const PUBLISHING_AMPLIFICATION_SCOPE_KINDS: readonly ["all", "tag", "post", "ugc_program", "ugc_peer_program"];
+export declare const publishingReadProjectionContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+}, never>;
+export declare const publishingReadWindowContract: ContractObject<{
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const publishingAmplificationListQueryContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly enabled: import("./schema.js").BooleanProperty;
+    readonly scope_kind: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["all", "tag", "post", "ugc_program", "ugc_peer_program"];
+    };
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const publishingAmplificationActionsQueryContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly post_id: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const publishingNotesQueryContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly resolved: import("./schema.js").BooleanProperty;
+    readonly after_comment_id: import("./schema.js").StringProperty;
+    readonly comment_id: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const publishingRevisionsQueryContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly before_revision: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly revision_number: {
+        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 publishingAnalyticsQueryContract: ContractObject<{
+    readonly projection: {
+        readonly type: "string";
+        readonly description?: string;
+        readonly minLength?: number;
+        readonly maxLength?: number;
+        readonly enum: readonly ["full", "summary", "value"];
+    };
+    readonly value_path: import("./schema.js").StringProperty;
+    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>;
+/** Select only the exact leaf contract's query fields. False and zero survive;
+ * null/undefined are absent. Other action fields never become query arguments. */
+export declare function publishingReadQueryParams(contract: Pick<ContractObject, "properties">, values: Record<string, unknown>): URLSearchParams;

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

@@ -0,0 +1,62 @@
+import { bool, int, obj, str } from "./schema.js";
+// These are the existing native store bounds, shared by the serving producer
+// and both agent interfaces. A zero HTTP limit keeps the shipped default.
+export const PUBLISHING_POLICY_LIST_LIMIT = 200;
+export const PUBLISHING_ACTION_LIST_LIMIT = 500;
+export const PUBLISHING_NOTE_LIST_LIMIT = 500;
+export const PUBLISHING_REVISION_LIST_LIMIT = 200;
+export const PUBLISHING_METRIC_LIST_LIMIT = 400;
+export const PUBLISHING_AMPLIFICATION_SCOPE_KINDS = ["all", "tag", "post", "ugc_program", "ugc_peer_program"];
+export const publishingReadProjectionContract = obj({
+    projection: { ...str({ description: "full default; summary lists exact child metadata/indices; value streams lossless canonical JSON. Follow next_cursor with the same scope." }), enum: ["full", "summary", "value"] },
+    value_path: str({ description: "Projection RFC6901 pointer: empty=root; /revisions/0/content_text, /comments/0/body, /series, /curve, /benchmarks or /accounts. No field is silently trimmed.", maxLength: 4096 }),
+    cursor: str({ description: "Signed projection continuation; repeat the same filters, projection and value_path. Changed data/scope/source refuses stale.", maxLength: 4096 }),
+});
+export const publishingReadWindowContract = obj({
+    max_chars: int({ minimum: 1_000, maximum: 48_000, description: "Model data window; oversize refuses whole. Widget UI transport is separate. Omit for legacy HTTP/CLI output." }),
+});
+const limit = (maximum, description) => int({ minimum: 0, maximum, clamp: true, description });
+export const publishingAmplificationListQueryContract = obj({
+    ...publishingReadProjectionContract.properties,
+    enabled: bool({ description: "list: true enabled, false disabled; omit for both." }),
+    scope_kind: { ...str({ description: "list scope; create: all/tag/post with matching target." }), enum: PUBLISHING_AMPLIFICATION_SCOPE_KINDS },
+    limit: limit(PUBLISHING_POLICY_LIST_LIMIT, "list policies, newest first; 0 uses native default 100."),
+    ...publishingReadWindowContract.properties,
+});
+export const publishingAmplificationActionsQueryContract = obj({
+    ...publishingReadProjectionContract.properties,
+    post_id: str({ description: "actions: scheduled post UUID filter." }),
+    limit: limit(PUBLISHING_ACTION_LIST_LIMIT, "actions ledger rows, newest first; 0 uses native default 100."),
+    ...publishingReadWindowContract.properties,
+});
+export const publishingNotesQueryContract = obj({
+    resolved: bool({ description: "list: true resolved, false unresolved; omit for both. resolve: default true." }),
+    after_comment_id: str({ description: "list: seek after this private note in native oldest-first order, within this post and resolved filter.", maxLength: 120 }),
+    comment_id: str({ description: "list: exact private note on this post; resolve: note to settle/reopen.", maxLength: 120 }),
+    ...publishingReadProjectionContract.properties,
+    limit: limit(PUBLISHING_NOTE_LIST_LIMIT, "list private notes, oldest first; 0 uses native default 200."),
+    ...publishingReadWindowContract.properties,
+});
+export const publishingRevisionsQueryContract = obj({
+    before_revision: int({ minimum: 1, description: "list: read revisions older than this number, newest first; native continuation of a limited history scope." }),
+    revision_number: int({ minimum: 1, description: "list: exact historical revision on this post; restore: revision to restore." }),
+    ...publishingReadProjectionContract.properties,
+    limit: limit(PUBLISHING_REVISION_LIST_LIMIT, "list revisions, newest first; 0 uses native default 50."),
+    ...publishingReadWindowContract.properties,
+});
+export const publishingAnalyticsQueryContract = obj({
+    ...publishingReadProjectionContract.properties,
+    limit: limit(PUBLISHING_METRIC_LIST_LIMIT, "post/account: total metric rows, newest first (not per account); 0 uses 90. summary: top posts, max 50. timeseries ignores it."),
+    ...publishingReadWindowContract.properties,
+});
+/** Select only the exact leaf contract's query fields. False and zero survive;
+ * null/undefined are absent. Other action fields never become query arguments. */
+export function publishingReadQueryParams(contract, values) {
+    const params = new URLSearchParams();
+    for (const key of Object.keys(contract.properties)) {
+        const value = values[key];
+        if (value !== undefined && value !== null)
+            params.set(key, String(value));
+    }
+    return params;
+}