@oxygen-agent/cli 1.906.0 → 1.922.12

package/node_modules/@oxygen/shared/dist/linkedin-url.d.ts

@@ -25,6 +25,28 @@ export type LinkedinUrlNormalization = {
     dispatchUrl: string;
 } | null;
 export declare function normalizeLinkedinProfileUrl(raw: string | null | undefined): LinkedinUrlNormalization;
+/**
+ * Canonicalize any LinkedIn PROFILE REFERENCE a customer might put in a cell:
+ * a full `/in/` URL, a scheme-less `linkedin.com/in/…`, or a BARE public handle
+ * (`peter-neumann-b25a6717b`, `christopherueink1`) that people-search exports
+ * and manual research routinely produce. Purely lexical — no provider call.
+ *
+ * The rule, in order:
+ *   1. Anything `normalizeLinkedinProfileUrl` accepts wins (URL forms).
+ *   2. A URL-shaped value it rejected (company page, Sales Navigator, a
+ *      non-LinkedIn host) stays rejected — never guessed at.
+ *   3. An `ACo…`/`ACw…` member provider id is NOT a handle. It returns null
+ *      because this function's contract is "give me a profile URL"; a caller
+ *      that accepts member ids must recognize them itself and pass them through
+ *      as an id. Fabricating `/in/ACoAA…` would address nobody.
+ *   4. What is left is a handle only if it matches the public-identifier charset
+ *      AND contains a letter AND contains a hyphen or digit AND is not a
+ *      placeholder token. Everything else returns null.
+ *
+ * A canonicalized handle is dispatchable the same way a URL is: send-time
+ * resolution (`users_get`) turns `/in/<handle>` into the real member id.
+ */
+export declare function canonicalizeLinkedinProfileReference(raw: string | null | undefined): LinkedinUrlNormalization;
 /**
  * Extract the addressable activity id from a LinkedIn post URL. Returns null for
  * a bare id (already addressable — pass it through), and null for a linkedin.com

package/node_modules/@oxygen/shared/dist/linkedin-url.js

@@ -65,6 +65,110 @@ export function normalizeLinkedinProfileUrl(raw) {
         dispatchUrl: `https://www.linkedin.com/in/${decoded}`,
     };
 }
+// A LinkedIn member PROVIDER id (Unipile `ACoAA…` / `ACwAA…`) is base64url of a
+// member URN, not a public identifier — rewriting one into `/in/<id>` would send
+// a nonexistent profile URL to the provider. Guard the whole PREFIX rather than a
+// length-qualified shape: a short or truncated id (`ACo123`) would otherwise slip
+// through and be dispatched as if it were a handle. LinkedIn mints public slugs
+// lowercase, so `acoustics-lab` is a real handle; the guard only fires on a
+// leading uppercase `AC`, and it tolerates the third letter being upper-cased
+// too (`ACOAA…`, the shape a spreadsheet UPPER() or a CRM export produces), so
+// such an id is named as unrecognized at enrollment instead of dying at send.
+const LINKEDIN_MEMBER_ID_PREFIX_RE = /^AC[OoWw]/;
+// LinkedIn's public identifier ("vanity slug") charset: letters, digits and
+// hyphens only, 3–100 characters, never leading with a hyphen. Deliberately
+// NARROWER than "any non-URL string" — no `.`, `@`, `_`, `:`, `/` or whitespace
+// — so an email (`someone@example.com`), a bare domain (`example.com`), and a
+// free-text research placeholder can never be mistaken for a handle and turned
+// into a dispatchable profile URL. Unicode letters/digits are allowed because
+// `normalizeLinkedinProfileUrl` already percent-decodes non-ASCII slugs.
+const LINKEDIN_PUBLIC_HANDLE_RE = /^[\p{L}\p{N}][\p{L}\p{N}-]{2,99}$/u;
+/**
+ * A bare handle is only accepted when it carries a hyphen or a digit — the
+ * `firstname-lastname-hash` / `name1` shapes LinkedIn actually mints and people
+ * search actually exports.
+ *
+ * THIS IS THE STRANGER-DISPATCH GUARD. Without it, every single plain word in a
+ * mis-mapped column becomes a dispatchable profile: `alexander`, `Schmidt`,
+ * `acme`, `microsoft`, `unknown`, `pending` all resolve to a REAL LinkedIn
+ * member who has nothing to do with the row, and outreach goes to a stranger
+ * under the customer's own account. A wrongly-skipped row is recoverable and is
+ * reported by name; a message to the wrong human is not. The cost is that a real
+ * separator-free vanity handle (`satyanadella`) must be supplied as a full URL —
+ * which the per-row `unrecognized_linkedin_identifier` detail tells the customer.
+ */
+const LINKEDIN_HANDLE_REQUIRES_SEPARATOR_OR_DIGIT = /[-\p{N}]/u;
+/** A handle must still contain a letter, so a phone number (`4915112345678`) is not one. */
+const LINKEDIN_HANDLE_REQUIRES_LETTER = /\p{L}/u;
+/**
+ * Values that pass the shape tests but are obviously a spreadsheet's way of
+ * saying "no value". They are compared case-insensitively against the whole
+ * trimmed cell WITH ITS HYPHENS REMOVED, so the hyphenated spellings that would
+ * otherwise satisfy the separator rule (`n-a`, `not-found`, `no-linkedin`,
+ * `url-to-confirm`) are caught by the same list as their plain forms.
+ */
+const LINKEDIN_HANDLE_PLACEHOLDER_TOKENS = new Set([
+    "none", "null", "nil", "undefined", "unknown", "missing", "pending", "tbd",
+    "todo", "error", "failed", "true", "false", "empty", "blank", "test", "na",
+    "notfound", "nolinkedin", "notonlinkedin", "noprofile", "nourl", "notavailable",
+    "notapplicable", "unavailable", "urltoconfirm", "tobeconfirmed", "toconfirm",
+    "placeholder", "sample", "example", "dummy", "unresolved",
+]);
+function isLinkedinHandlePlaceholder(value) {
+    return LINKEDIN_HANDLE_PLACEHOLDER_TOKENS.has(value.toLowerCase().replace(/-/g, ""));
+}
+/**
+ * Canonicalize any LinkedIn PROFILE REFERENCE a customer might put in a cell:
+ * a full `/in/` URL, a scheme-less `linkedin.com/in/…`, or a BARE public handle
+ * (`peter-neumann-b25a6717b`, `christopherueink1`) that people-search exports
+ * and manual research routinely produce. Purely lexical — no provider call.
+ *
+ * The rule, in order:
+ *   1. Anything `normalizeLinkedinProfileUrl` accepts wins (URL forms).
+ *   2. A URL-shaped value it rejected (company page, Sales Navigator, a
+ *      non-LinkedIn host) stays rejected — never guessed at.
+ *   3. An `ACo…`/`ACw…` member provider id is NOT a handle. It returns null
+ *      because this function's contract is "give me a profile URL"; a caller
+ *      that accepts member ids must recognize them itself and pass them through
+ *      as an id. Fabricating `/in/ACoAA…` would address nobody.
+ *   4. What is left is a handle only if it matches the public-identifier charset
+ *      AND contains a letter AND contains a hyphen or digit AND is not a
+ *      placeholder token. Everything else returns null.
+ *
+ * A canonicalized handle is dispatchable the same way a URL is: send-time
+ * resolution (`users_get`) turns `/in/<handle>` into the real member id.
+ */
+export function canonicalizeLinkedinProfileReference(raw) {
+    const fromUrl = normalizeLinkedinProfileUrl(raw);
+    if (fromUrl)
+        return fromUrl;
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    // A URL we could not reduce to a profile is a rejection, not a handle.
+    if (looksLikeUrlIdentifier(trimmed))
+        return null;
+    if (LINKEDIN_MEMBER_ID_PREFIX_RE.test(trimmed))
+        return null;
+    if (!LINKEDIN_PUBLIC_HANDLE_RE.test(trimmed))
+        return null;
+    if (!LINKEDIN_HANDLE_REQUIRES_LETTER.test(trimmed))
+        return null;
+    if (!LINKEDIN_HANDLE_REQUIRES_SEPARATOR_OR_DIGIT.test(trimmed))
+        return null;
+    if (isLinkedinHandlePlaceholder(trimmed))
+        return null;
+    const handle = trimmed.toLowerCase();
+    return {
+        normalized: `https://www.linkedin.com/in/${handle}`,
+        handle,
+        // dispatchHandle keeps the original case, exactly as the URL path does.
+        dispatchHandle: trimmed,
+        dispatchUrl: `https://www.linkedin.com/in/${trimmed}`,
+    };
+}
 // A LinkedIn post URL carries the numeric activity id we address the post by:
 //   /posts/{slug}-activity-{19 digits}-{4 chars}
 //   /feed/update/urn:li:activity:{19 digits}

package/node_modules/@oxygen/shared/dist/provider-funding-errors.d.ts

@@ -40,5 +40,19 @@ export declare function isProviderFundingErrorCode(code: string | null | undefin
  * would otherwise read as retryable.
  */
 export declare function isProviderRateLimitErrorCode(code: string | null | undefined): boolean;
-/** The customer-facing next step for a funding refusal, by credential ownership. */
-export declare function providerFundingNextStep(credentialMode: "managed" | "byok" | null | undefined): string;
+/**
+ * True when the credential the provider refused belongs to the CUSTOMER rather
+ * than to Oxygen's managed pool.
+ *
+ * The two halves of a 402 need opposite copy and opposite promises. Oxygen's own
+ * dry account is our outage: the breaker benches the provider, the row is
+ * preserved, and the work resumes once ops funds it. A customer-owned account is
+ * theirs to top up: nothing resumes, nobody is alerted, and telling them to wait
+ * is how one workspace re-ran the same column every few hours for nine days.
+ *
+ * The producers spell customer ownership four ways (`byok` for an explicit
+ * bring-your-own key, `user_oauth` / `user_api_key` / `user_connection` for a
+ * connected account) — every one of them is the customer's money, so the
+ * predicate is "not managed", not "equals byok".
+ */
+export declare function isCustomerOwnedCredentialMode(credentialMode: string | null | undefined): boolean;

package/node_modules/@oxygen/shared/dist/provider-funding-errors.js

@@ -69,13 +69,23 @@ export function isProviderRateLimitErrorCode(code) {
         return false;
     return /rate|limit|429|capacity_deferred/i.test(code);
 }
-/** The customer-facing next step for a funding refusal, by credential ownership. */
-export function providerFundingNextStep(credentialMode) {
-    if (credentialMode === "byok") {
-        return "Top up or upgrade the provider account behind your connected key, then retry. Waiting will not clear this.";
-    }
-    if (credentialMode === "managed") {
-        return "This is OXYGEN's managed provider account, not your credit balance — contact support. Waiting will not clear this; route the run to another provider in the meantime.";
-    }
-    return "Check the provider account's balance and plan entitlement, then retry. Waiting will not clear this.";
+/**
+ * True when the credential the provider refused belongs to the CUSTOMER rather
+ * than to Oxygen's managed pool.
+ *
+ * The two halves of a 402 need opposite copy and opposite promises. Oxygen's own
+ * dry account is our outage: the breaker benches the provider, the row is
+ * preserved, and the work resumes once ops funds it. A customer-owned account is
+ * theirs to top up: nothing resumes, nobody is alerted, and telling them to wait
+ * is how one workspace re-ran the same column every few hours for nine days.
+ *
+ * The producers spell customer ownership four ways (`byok` for an explicit
+ * bring-your-own key, `user_oauth` / `user_api_key` / `user_connection` for a
+ * connected account) — every one of them is the customer's money, so the
+ * predicate is "not managed", not "equals byok".
+ */
+export function isCustomerOwnedCredentialMode(credentialMode) {
+    if (!credentialMode)
+        return false;
+    return credentialMode.trim().toLowerCase() !== "managed";
 }

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

@@ -1,2 +1,20 @@
 export declare const MAX_TABLE_ACTION_RUN_ROWS = 500000;
 export declare const MAX_WORKSPACE_ROW_DELETE_ROWS = 50000;
+/**
+ * Platform ceiling for a table action run's `max_concurrency` (T-27).
+ *
+ * The API used to accept 1..1000 and silently throttle anything the worker could
+ * not serve (the August incident: a customer set 200-250 and watched it behave
+ * nothing like the number they chose). This is the honest upper bound: 250, the
+ * highest per-run in-flight ceiling ANY lane genuinely serves — the set-wise
+ * link_batch lane (LINK_BATCH_ROWS = 250 in the worker scheduler). No run type is
+ * validated below its real cap.
+ *
+ * It is deliberately NOT the external-tool provider feeder cap
+ * (EXTERNAL_TOOL_RUN_FEEDER_CAP = 160, an independent constant in the worker):
+ * an external_tool run is accepted up to this ceiling and the worker bounds it at
+ * 160 in-flight, and the create envelope reports that lower effective ceiling
+ * honestly (max_concurrency_platform_ceiling / max_concurrency_provider_ceiling)
+ * rather than under-serving link runs to make one flat number "true".
+ */
+export declare const MAX_TABLE_ACTION_RUN_MAX_CONCURRENCY = 250;

package/node_modules/@oxygen/shared/dist/table-limits.js

@@ -2,3 +2,21 @@
 // surface that resolves a symbolic row selection before invoking it.
 export const MAX_TABLE_ACTION_RUN_ROWS = 500_000;
 export const MAX_WORKSPACE_ROW_DELETE_ROWS = 50_000;
+/**
+ * Platform ceiling for a table action run's `max_concurrency` (T-27).
+ *
+ * The API used to accept 1..1000 and silently throttle anything the worker could
+ * not serve (the August incident: a customer set 200-250 and watched it behave
+ * nothing like the number they chose). This is the honest upper bound: 250, the
+ * highest per-run in-flight ceiling ANY lane genuinely serves — the set-wise
+ * link_batch lane (LINK_BATCH_ROWS = 250 in the worker scheduler). No run type is
+ * validated below its real cap.
+ *
+ * It is deliberately NOT the external-tool provider feeder cap
+ * (EXTERNAL_TOOL_RUN_FEEDER_CAP = 160, an independent constant in the worker):
+ * an external_tool run is accepted up to this ceiling and the worker bounds it at
+ * 160 in-flight, and the create envelope reports that lower effective ceiling
+ * honestly (max_concurrency_platform_ceiling / max_concurrency_provider_ceiling)
+ * rather than under-serving link runs to make one flat number "true".
+ */
+export const MAX_TABLE_ACTION_RUN_MAX_CONCURRENCY = 250;

package/node_modules/@oxygen/shared/dist/user-capability-routing.js

@@ -1,4 +1,4 @@
-import { getCapabilityRouteMatch, inferCapabilityRoute, } from "./capability-discovery.js";
+import { getCapabilityRoute, getCapabilityRouteMatch, inferCapabilityRoute, } from "./capability-discovery.js";
 // Provider brands are intentionally not duplicated into the static capability
 // catalog. A short "connect <provider>" query would otherwise match Tables via
 // its relationship-oriented "connect" term. Correct that narrow ambiguity at
@@ -13,9 +13,30 @@ export function inferUserCapabilityRoute(query) {
     }
     return getCapabilityRouteMatch("connected-integrations") ?? route;
 }
+// The words that mean "this is Tables work, not a provider connection". Hand-typing
+// them drifted: the list covered table/row/column/dataset/join/relate but not csv,
+// import, enrich, waterfall, formula, lookup or score -- all of which the Tables card
+// itself claims. The measured cost was 11 queries ("connect my csv", "connect my
+// enrichment", "connect my formula") losing their Tables tools and being handed
+// oxygen_integrations_connect instead, on ALL THREE surfaces that call this wrapper.
+//
+// So derive from the card rather than restating it. `connect` is excluded because it
+// is the ambiguity itself -- it is a Tables intent term AND the verb this function
+// keys on, and leaving it in would make the guard reject every query the wrapper
+// exists to correct.
+const TABLES_INTENT_AMBIGUITY_TRIGGERS = new Set(["connect"]);
+function tablesIntentGuard() {
+    const terms = (getCapabilityRoute("tables")?.intentTerms ?? [])
+        .filter((term) => !TABLES_INTENT_AMBIGUITY_TRIGGERS.has(term))
+        .flatMap((term) => (term.includes(" ") ? [term] : [term, `${term}s`]))
+        .map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .sort((a, b) => b.length - a.length);
+    return new RegExp(`\\b(?:${terms.join("|")})\\b`);
+}
+const TABLES_INTENT_GUARD = tablesIntentGuard();
 function isSimpleProviderConnectionIntent(query) {
     const normalized = query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
-    if (/\b(table|tables|row|rows|column|columns|dataset|join|relationship|relate)\b/.test(normalized)) {
+    if (TABLES_INTENT_GUARD.test(normalized)) {
         return false;
     }
     if (/\b(integration|provider|oauth|byok|api key|connected account)\b/.test(normalized)) {

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.906.0";
+export declare const OXYGEN_VERSION = "1.922.12";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";
 export declare const SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION = "1.747.0";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.906.0";
+export const OXYGEN_VERSION = "1.922.12";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/node_modules/@oxygen/shared/package.json

@@ -96,6 +96,11 @@
       "import": "./dist/dnc-identities.js",
       "default": "./dist/dnc-identities.js"
     },
+    "./provider-funding-errors": {
+      "types": "./dist/provider-funding-errors.d.ts",
+      "import": "./dist/provider-funding-errors.js",
+      "default": "./dist/provider-funding-errors.js"
+    },
     "./cli-result": {
       "types": "./dist/cli-result.d.ts",
       "import": "./dist/cli-result.js",
@@ -141,6 +146,11 @@
       "import": "./dist/pricing-sheet.js",
       "default": "./dist/pricing-sheet.js"
     },
+    "./copilot-plan": {
+      "types": "./dist/copilot-plan.d.ts",
+      "import": "./dist/copilot-plan.js",
+      "default": "./dist/copilot-plan.js"
+    },
     "./copilot-journeys": {
       "types": "./dist/copilot-journeys.d.ts",
       "import": "./dist/copilot-journeys.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.906.0",
+  "version": "1.922.12",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -34,6 +34,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.1050.0",
     "@aws-sdk/s3-request-presigner": "3.1050.0",
+    "@langfuse/core": "^5.11.0",
     "@langfuse/otel": "^5.11.0",
     "@langfuse/tracing": "^5.11.0",
     "@opentelemetry/api": "1.9.1",