@kortix/ui 0.14.8 → 0.14.10

package/dist/customize/connectors/install/way-kind.js

@@ -0,0 +1,16 @@
+const LABELS = {
+    mcp: 'MCP',
+    composio: 'Composio',
+    kortix: 'Kortix',
+    pipedream: 'Pipedream',
+    openapi: 'REST API',
+    graphql: 'GraphQL',
+    postman: 'Postman',
+    http: 'HTTP API',
+    // Kept for the SDK type: the catalogue no longer lists CLIs.
+    cli: 'CLI',
+};
+/** The badge a way to connect carries everywhere: cards, the app page, Install. */
+export function wayKindLabel(kind) {
+    return LABELS[kind] ?? kind.toUpperCase();
+}

package/dist/customize/connectors/provider-label.d.ts

@@ -1,6 +1,7 @@
 import type { AdminConnector } from '@kortix/sdk';
 /**
- * Forward-facing provider label — "App" for the 1-click (Pipedream) connectors.
+ * Forward-facing provider label. A managed connector names its partner
+ * (Composio, Pipedream): it is never just an "App".
  *
  * Lives here, in the connectors feature folder, rather than in
  * `customize/sections/connectors-view.tsx` where it started. That module is

package/dist/customize/connectors/provider-label.js

@@ -1,5 +1,6 @@
 /**
- * Forward-facing provider label — "App" for the 1-click (Pipedream) connectors.
+ * Forward-facing provider label. A managed connector names its partner
+ * (Composio, Pipedream): it is never just an "App".
  *
  * Lives here, in the connectors feature folder, rather than in
  * `customize/sections/connectors-view.tsx` where it started. That module is
@@ -13,14 +14,23 @@
  * deliberate: when `connectors-view.tsx` is retired, this module does not move.
  */
 export function providerLabel(p) {
-    if (isManagedConnectorProvider(p))
-        return 'App';
+    if (p === 'composio')
+        return 'Composio';
+    if (p === 'pipedream')
+        return 'Pipedream';
     if (p === 'channel')
         return 'Channel';
     if (p === 'computer')
         return 'Computer';
     if (p === 'postman')
         return 'Postman';
+    // The catalogue's words for the same ways in (`install/way-kind.ts`).
+    if (p === 'openapi')
+        return 'REST API';
+    if (p === 'graphql')
+        return 'GraphQL';
+    if (p === 'http')
+        return 'HTTP API';
     return p.toUpperCase();
 }
 /** Providers whose accounts are authorized through the normalized Connect Link gateway. */

package/dist/customize/connectors/tools/pattern-rule-draft.d.ts

@@ -5,6 +5,10 @@ export interface PatternDraftRow {
     id: string;
     match: string;
     action: ConnectorPolicyAction;
+    /** Argument conditions authored in kortix.yaml. The editor has no control
+     *  for them, so they ride along untouched: dropping them on save would turn
+     *  a conditional rule into an unconditional one. */
+    conditions?: ConnectorPolicyRule['conditions'];
 }
 /**
  * A content signature for a set of pattern rules, immune to the one reordering

package/dist/customize/connectors/tools/pattern-rule-draft.js

@@ -26,12 +26,17 @@ import { orderPolicyRules } from './tool-policy.js';
  */
 export function signPatternRules(rules) {
     return orderPolicyRules(rules)
-        .map((rule) => `${rule.match}=${rule.action}`)
+        .map((rule) => `${rule.match}=${rule.action}${rule.conditions?.length ? JSON.stringify(rule.conditions) : ''}`)
         .join('\n');
 }
 /** The draft rows a rule set seeds, in the order the rules arrived. */
 export function seedPatternDraft(rules, nextId) {
-    return rules.map((rule) => ({ id: nextId(), match: rule.match, action: rule.action }));
+    return rules.map((rule) => ({
+        id: nextId(),
+        match: rule.match,
+        action: rule.action,
+        ...(rule.conditions?.length ? { conditions: rule.conditions } : {}),
+    }));
 }
 /** The wire form of a draft: blank rows dropped, every match trimmed, `id`
  *  gone. Shared by the dirty check and the save, so the two can never disagree
@@ -39,5 +44,9 @@ export function seedPatternDraft(rules, nextId) {
 export function draftToRules(draft) {
     return draft
         .filter((row) => row.match.trim())
-        .map((row) => ({ match: row.match.trim(), action: row.action }));
+        .map((row) => ({
+        match: row.match.trim(),
+        action: row.action,
+        ...(row.conditions?.length ? { conditions: row.conditions } : {}),
+    }));
 }

package/dist/customize/connectors/tools/policy-sets.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Connector policy sets: named rule lists on one connector that an agent is
+ * given with `agents.<a>.policy_sets.<slug>` in kortix.yaml. The connector's
+ * own `policies:` are the base rules. The API owns the shape; these helpers
+ * are what the Tools tab and the agent editor need on top of it.
+ */
+/**
+ * Channel and computer connectors have no kortix.yaml entry, so they cannot
+ * carry sets (the API answers 400 `policy_sets_unsupported`). The switcher is
+ * hidden there.
+ */
+export declare function supportsPolicySets(provider: string | null | undefined): boolean;
+export type PolicySetNameProblem = 'invalid' | 'taken';
+/**
+ * Why a name cannot be used for a new or renamed set, or null. `current` is
+ * the set being renamed: keeping its own name is not a clash.
+ */
+export declare function policySetNameProblem(name: string, existing: readonly string[], current?: string | null): PolicySetNameProblem | null;
+/** The react-query key of one connector's set list. */
+export declare function connectorPolicySetsKey(projectId: string, slug: string): readonly ["connector-policy-sets", string, string];
+/** The react-query key of one rule list: the base rules (`null`) or one set. */
+export declare function connectorPoliciesKey(projectId: string, slug: string, policySet: string | null): readonly ["connector-policies", string, string, string | null];
+/** A starting point for a new set. `empty` inherits every tool from the base rules. */
+export type PolicySetTemplate = 'empty' | 'read_only' | 'ask_before_writes';
+export declare const POLICY_SET_TEMPLATES: readonly PolicySetTemplate[];
+/** The name a template proposes. */
+export declare const TEMPLATE_NAME: Record<PolicySetTemplate, string>;

package/dist/customize/connectors/tools/policy-sets.js

@@ -0,0 +1,41 @@
+import { POLICY_SETS_UNSUPPORTED_PROVIDERS, policySetNameError, } from '../../../_vendor/kortix-shared.js';
+/**
+ * Connector policy sets: named rule lists on one connector that an agent is
+ * given with `agents.<a>.policy_sets.<slug>` in kortix.yaml. The connector's
+ * own `policies:` are the base rules. The API owns the shape; these helpers
+ * are what the Tools tab and the agent editor need on top of it.
+ */
+/**
+ * Channel and computer connectors have no kortix.yaml entry, so they cannot
+ * carry sets (the API answers 400 `policy_sets_unsupported`). The switcher is
+ * hidden there.
+ */
+export function supportsPolicySets(provider) {
+    return !POLICY_SETS_UNSUPPORTED_PROVIDERS.includes((provider ?? '').trim().toLowerCase());
+}
+/**
+ * Why a name cannot be used for a new or renamed set, or null. `current` is
+ * the set being renamed: keeping its own name is not a clash.
+ */
+export function policySetNameProblem(name, existing, current = null) {
+    if (policySetNameError(name))
+        return 'invalid';
+    if (name !== current && existing.includes(name))
+        return 'taken';
+    return null;
+}
+/** The react-query key of one connector's set list. */
+export function connectorPolicySetsKey(projectId, slug) {
+    return ['connector-policy-sets', projectId, slug];
+}
+/** The react-query key of one rule list: the base rules (`null`) or one set. */
+export function connectorPoliciesKey(projectId, slug, policySet) {
+    return ['connector-policies', projectId, slug, policySet];
+}
+export const POLICY_SET_TEMPLATES = ['read_only', 'ask_before_writes', 'empty'];
+/** The name a template proposes. */
+export const TEMPLATE_NAME = {
+    empty: '',
+    read_only: 'read_only',
+    ask_before_writes: 'ask_before_writes',
+};

package/dist/customize/connectors/tools/tool-groups.d.ts

@@ -1,23 +1,34 @@
 import type { UiTranslator } from '../../../i18n/index.js';
 import type { ConnectorAction } from '@kortix/sdk';
 export interface ToolGroup {
-    key: 'read' | 'write';
+    key: 'read' | 'write' | 'unclassified';
     label: string;
     actions: ConnectorAction[];
 }
 /**
- * Two buckets, because that is the only distinction a non-technical reader
- * needs before granting access: can this look at my data, or change it.
- * `destructive` folds into writes — a delete is a write with worse consequences,
- * and a third bucket would just make the safe/unsafe line harder to see.
+ * Which bucket a tool sits in. The server's `likely_risk` wins, then the
+ * stored risk. A tool the server could not classify (`unknown`, sent once tool risk is
+ * inferred server side) goes by its name, without the app prefix:
+ * `LINEAR_GET_ISSUE` reads, `send_email` writes, and the rest are
+ * unclassified. It is never shown as a write it may not be.
+ */
+export declare function toolBucket(action: Pick<ConnectorAction, 'path' | 'name'> & {
+    risk: string;
+    likely_risk?: string;
+}, appNames?: readonly string[]): ToolGroup['key'];
+/**
+ * Three buckets: can this look at my data, can it change it, or does nobody
+ * know yet. `destructive` folds into writes: a delete is a write with worse
+ * consequences. Unclassified is its own bucket, so an unknown tool is never
+ * presented as safe or as a write.
  *
  * An empty bucket is omitted rather than rendered as a heading over nothing.
  * Input order is kept inside each bucket: that is the order the connector
  * reports its tools in, which is the order its own docs use.
  */
-export declare function groupToolsByRisk(actions: readonly ConnectorAction[], tI18nComplete: UiTranslator): ToolGroup[];
+export declare function groupToolsByRisk(actions: readonly ConnectorAction[], tI18nComplete: UiTranslator, appNames?: readonly string[]): ToolGroup[];
 export interface ToolRowText {
-    /** The row's heading. */
+    /** The row's heading, in words: `LINEAR_ARCHIVE_ISSUE` reads "Archive issue". */
     title: string;
     /** The tool path, or `null` when the title already IS the path. */
     path: string | null;
@@ -30,9 +41,21 @@ export interface ToolRowText {
  * An OpenAPI connector commonly derives both `name` and `description` from the
  * same `summary` — the live `petstore` fixture does for all 19 of its tools —
  * so a naive row renders "Deletes a pet." over "Deletes a pet." The path is
- * dropped the same way when the connector never gave the tool a real name.
+ * dropped the same way when the title is the path itself.
+ *
+ * `appNames` are the connector's slug and names: a title drops the one it
+ * starts with, because every row on the page already belongs to that app.
+ */
+export declare function toolRowText(action: ConnectorAction, appNames?: readonly string[]): ToolRowText;
+/**
+ * A tool id as a sentence-case title. `LINEAR_ARCHIVE_ISSUE` with app name
+ * `linear` reads "Archive issue"; `ask_wiki_question` reads "Ask wiki
+ * question"; `getPetById` reads "Get pet by id".
+ *
+ * Only an identifier is rewritten. A name with a space is the connector's own
+ * wording and stays as it is. A prefix is dropped only when words remain.
  */
-export declare function toolRowText(action: ConnectorAction): ToolRowText;
+export declare function humanizeToolName(name: string, appNames?: readonly string[]): string;
 /**
  * Narrow a tool list by a free-text query. A connector with 60 tools is
  * unusable without one.

package/dist/customize/connectors/tools/tool-groups.js

@@ -1,22 +1,49 @@
+const READ_NAME = /^(get|list|read|search|fetch|find|query|describe|lookup|view|show|count|check)(?:\s|$)/i;
+const WRITE_NAME = /^(create|update|delete|send|post|remove|archive|set|add|edit|patch|put|insert|upsert|move|reply|cancel|close|invite|upload|merge|assign)(?:\s|$)/i;
 /**
- * Two buckets, because that is the only distinction a non-technical reader
- * needs before granting access: can this look at my data, or change it.
- * `destructive` folds into writes — a delete is a write with worse consequences,
- * and a third bucket would just make the safe/unsafe line harder to see.
+ * Which bucket a tool sits in. The server's `likely_risk` wins, then the
+ * stored risk. A tool the server could not classify (`unknown`, sent once tool risk is
+ * inferred server side) goes by its name, without the app prefix:
+ * `LINEAR_GET_ISSUE` reads, `send_email` writes, and the rest are
+ * unclassified. It is never shown as a write it may not be.
+ */
+export function toolBucket(action, appNames = []) {
+    // `likely_risk` is the server's reading for display; `risk` stays what the
+    // gateway enforces (an un-annotated MCP tool is stored as `write`).
+    const risk = action.likely_risk ?? action.risk;
+    if (risk === 'read')
+        return 'read';
+    if (risk === 'write' || risk === 'destructive')
+        return 'write';
+    const words = humanizeToolName(action.name?.trim() || action.path, appNames);
+    if (READ_NAME.test(words))
+        return 'read';
+    if (WRITE_NAME.test(words))
+        return 'write';
+    return 'unclassified';
+}
+/**
+ * Three buckets: can this look at my data, can it change it, or does nobody
+ * know yet. `destructive` folds into writes: a delete is a write with worse
+ * consequences. Unclassified is its own bucket, so an unknown tool is never
+ * presented as safe or as a write.
  *
  * An empty bucket is omitted rather than rendered as a heading over nothing.
  * Input order is kept inside each bucket: that is the order the connector
  * reports its tools in, which is the order its own docs use.
  */
-export function groupToolsByRisk(actions, tI18nComplete) {
-    const read = actions.filter((a) => a.risk === 'read');
-    const write = actions.filter((a) => a.risk !== 'read');
-    const groups = [];
-    if (read.length)
-        groups.push({ key: 'read', label: tI18nComplete.raw('textdd28b5cb26fd'), actions: read });
-    if (write.length)
-        groups.push({ key: 'write', label: tI18nComplete.raw('texted26c1af81cf'), actions: write });
-    return groups;
+export function groupToolsByRisk(actions, tI18nComplete, appNames = []) {
+    const buckets = { read: [], write: [], unclassified: [] };
+    for (const action of actions)
+        buckets[toolBucket(action, appNames)].push(action);
+    const labels = {
+        read: tI18nComplete.raw('textdd28b5cb26fd'),
+        write: tI18nComplete.raw('texted26c1af81cf'),
+        unclassified: tI18nComplete.raw('text7c0a91e5b3d2'),
+    };
+    return ['read', 'write', 'unclassified']
+        .filter((key) => buckets[key].length > 0)
+        .map((key) => ({ key, label: labels[key], actions: buckets[key] }));
 }
 /**
  * What one row prints, with nothing said twice.
@@ -24,12 +51,15 @@ export function groupToolsByRisk(actions, tI18nComplete) {
  * An OpenAPI connector commonly derives both `name` and `description` from the
  * same `summary` — the live `petstore` fixture does for all 19 of its tools —
  * so a naive row renders "Deletes a pet." over "Deletes a pet." The path is
- * dropped the same way when the connector never gave the tool a real name.
+ * dropped the same way when the title is the path itself.
+ *
+ * `appNames` are the connector's slug and names: a title drops the one it
+ * starts with, because every row on the page already belongs to that app.
  */
-export function toolRowText(action) {
+export function toolRowText(action, appNames = []) {
     const name = action.name?.trim();
     const description = action.description?.trim();
-    const title = name || action.path;
+    const title = humanizeToolName(name || action.path, appNames);
     const same = (value) => Boolean(value) && value.toLowerCase() === title.toLowerCase();
     return {
         title,
@@ -37,6 +67,38 @@ export function toolRowText(action) {
         description: !description || same(description) ? null : description,
     };
 }
+const IDENTIFIER = /^[A-Za-z0-9_.\-/:]+$/;
+const normalize = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+/**
+ * A tool id as a sentence-case title. `LINEAR_ARCHIVE_ISSUE` with app name
+ * `linear` reads "Archive issue"; `ask_wiki_question` reads "Ask wiki
+ * question"; `getPetById` reads "Get pet by id".
+ *
+ * Only an identifier is rewritten. A name with a space is the connector's own
+ * wording and stays as it is. A prefix is dropped only when words remain.
+ */
+export function humanizeToolName(name, appNames = []) {
+    const trimmed = name.trim();
+    if (!IDENTIFIER.test(trimmed))
+        return trimmed;
+    const words = trimmed
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[\s_.\-/:]+/)
+        .filter(Boolean)
+        .map((word) => word.toLowerCase());
+    if (words.length === 0)
+        return trimmed;
+    const apps = new Set(appNames.map(normalize).filter(Boolean));
+    // Up to three words: `GOOGLE_SHEETS_ADD_ROW` with app `googlesheets`.
+    for (let take = Math.min(3, words.length - 1); take > 0; take--) {
+        if (apps.has(words.slice(0, take).join(''))) {
+            words.splice(0, take);
+            break;
+        }
+    }
+    const sentence = words.join(' ');
+    return sentence.charAt(0).toUpperCase() + sentence.slice(1);
+}
 /**
  * Narrow a tool list by a free-text query. A connector with 60 tools is
  * unusable without one.

package/dist/customize/connectors/tools/tool-policy-control.d.ts

@@ -9,22 +9,23 @@ export interface ToolPolicyControlProps {
     disabled?: boolean;
     /** Set when a project rule decides this tool: disables the group and says why. */
     lockedReason?: string;
-    /** Shown while `value` is `'default'` — what following the default DOES. */
-    defaultHint?: string;
+    /** Replaces the Default segment's label with what it resolves to: "Default · runs", "Inherit · asks". */
+    defaultLabel?: string;
 }
 /**
  * The per-tool decision: four segments, four states, every one reachable in
  * both directions.
  *
- * `'default'` presses its own segment and a `Hint` names what the default
- * actually does, because "Default" alone does not tell a reader whether the
- * tool runs or asks.
+ * It is the segmented track of `Tabs` (`tabs.tsx`): a recessed track and one
+ * raised chip, so the choice reads at a glance down a 60-row list. It is not
+ * a tablist: each segment is a toggle button with `aria-pressed`.
+ *
+ * `'default'` carries the label the caller gives it ("Default · runs",
+ * "Inherit · asks"), because "Default" alone does not tell a reader whether
+ * the tool runs or asks.
  *
  * `transition-[…,scale]`, not `transition-transform`: Tailwind v4's `scale-*`
  * utility sets the standalone `scale` property, which
- * `transition-property: transform` does not cover — the press would snap. The
- * explicit list also replaces `Button`'s base `transition-all`
- * (`button.tsx:8`), which the polish rules treat as a defect. Same override,
- * same reason, as `project-icon-field.tsx:217`.
+ * `transition-property: transform` does not cover — the press would snap.
  */
-export declare function ToolPolicyControl({ value, onChange, label, disabled, lockedReason, defaultHint, }: ToolPolicyControlProps): import("react").JSX.Element;
+export declare function ToolPolicyControl({ value, onChange, label, disabled, lockedReason, defaultLabel, }: ToolPolicyControlProps): import("react").JSX.Element;

package/dist/customize/connectors/tools/tool-policy-control.js

@@ -1,8 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Button } from '../../../primitives/button.js';
-import { ButtonGroup } from '../../../primitives/button-group.js';
 import Hint from '../../../primitives/hint.js';
+import { tabsSegmentedChipClasses, tabsSegmentedTrackClasses } from '../../../primitives/tabs.js';
 import { cn } from '../../../internal/lib/utils.js';
 import { useLocalizedUiCatalog } from '../../../i18n/ui-catalog/use-localized-ui-catalog.js';
 import { POLICY_SEGMENTS } from './tool-policy-labels.js';
@@ -10,29 +9,32 @@ import { POLICY_SEGMENTS } from './tool-policy-labels.js';
  * The per-tool decision: four segments, four states, every one reachable in
  * both directions.
  *
- * `'default'` presses its own segment and a `Hint` names what the default
- * actually does, because "Default" alone does not tell a reader whether the
- * tool runs or asks.
+ * It is the segmented track of `Tabs` (`tabs.tsx`): a recessed track and one
+ * raised chip, so the choice reads at a glance down a 60-row list. It is not
+ * a tablist: each segment is a toggle button with `aria-pressed`.
+ *
+ * `'default'` carries the label the caller gives it ("Default · runs",
+ * "Inherit · asks"), because "Default" alone does not tell a reader whether
+ * the tool runs or asks.
  *
  * `transition-[…,scale]`, not `transition-transform`: Tailwind v4's `scale-*`
  * utility sets the standalone `scale` property, which
- * `transition-property: transform` does not cover — the press would snap. The
- * explicit list also replaces `Button`'s base `transition-all`
- * (`button.tsx:8`), which the polish rules treat as a defect. Same override,
- * same reason, as `project-icon-field.tsx:217`.
+ * `transition-property: transform` does not cover — the press would snap.
  */
-export function ToolPolicyControl({ value, onChange, label, disabled = false, lockedReason, defaultHint, }) {
+export function ToolPolicyControl({ value, onChange, label, disabled = false, lockedReason, defaultLabel, }) {
     const policySegments = useLocalizedUiCatalog(POLICY_SEGMENTS);
     const locked = Boolean(lockedReason);
-    const group = (_jsx(ButtonGroup, { "aria-label": label, className: "shrink-0", children: policySegments.map((segment) => {
+    const group = (_jsx("div", { role: "group", "aria-label": label, className: cn(tabsSegmentedTrackClasses, 'inline-flex h-7 shrink-0 items-stretch gap-0.5'), children: policySegments.map((segment) => {
             const selected = value === segment.choice;
-            return (_jsx(Button, { type: "button", size: "sm", variant: selected ? 'secondary-outline' : 'outline', "aria-pressed": selected, disabled: disabled || locked, 
+            return (_jsx("button", { type: "button", "aria-pressed": selected, disabled: disabled || locked, 
                 // Re-pressing the current choice is a no-op, not a redundant PUT
                 // that rewrites the rule set to what it already is.
                 onClick: () => {
                     if (!selected)
                         onChange(segment.choice);
-                }, className: cn('px-2.5 text-xs font-medium', 'transition-[color,background-color,scale] duration-150 active:scale-[0.96]', selected ? segment.tint : cn('text-muted-foreground', segment.hoverTint)), children: segment.label }, segment.choice));
+                }, className: cn('rounded-sm px-2 text-xs font-medium whitespace-nowrap', 'focus-visible:ring-kortix-blue focus-visible:ring-[0.6px] focus-visible:outline-none', 'disabled:pointer-events-none disabled:opacity-50', 'transition-[color,background-color,box-shadow,scale] duration-normal ease-default active:scale-[0.96] motion-reduce:transition-none', selected
+                    ? cn(tabsSegmentedChipClasses, segment.tint)
+                    : cn('text-muted-foreground', segment.hoverTint)), children: segment.choice === 'default' && defaultLabel ? defaultLabel : segment.label }, segment.choice));
         }) }));
     // A disabled control with no explanation is a dead end. The segments carry
     // `disabled:pointer-events-none`, so the pointer reaches this wrapper and the
@@ -40,8 +42,5 @@ export function ToolPolicyControl({ value, onChange, label, disabled = false, lo
     if (lockedReason) {
         return (_jsx(Hint, { label: lockedReason, side: "bottom", children: _jsx("div", { className: "shrink-0", children: group }) }));
     }
-    if (value === 'default' && defaultHint) {
-        return (_jsx(Hint, { label: defaultHint, side: "bottom", children: _jsx("div", { className: "shrink-0", children: group }) }));
-    }
     return group;
 }

package/dist/customize/connectors/tools/tool-policy-labels.d.ts

@@ -17,14 +17,15 @@ export interface PolicySegment {
     hoverTint: string;
 }
 /**
- * Default · Block · Ask · Allow.
+ * Default · Allow · Ask · Block.
  *
  * FOUR segments, because there are genuinely four states. Default sits first
- * because it is the state every tool starts in, and because the remaining three
- * then read left-to-right as a trust dial: least on the left, most on the right.
+ * because it is the state every tool starts in; the control labels it with
+ * what it resolves to ("Default · runs").
  *
- * Default carries no tint. Inheriting is not a decision, and colouring it would
- * put a fourth hue in every row of a 60-tool connector.
+ * Only Block carries a hue, the destructive token. Allow and Ask are plain
+ * ink: a 60-tool list in three status colours reads as noise, and the word
+ * already says the decision.
  */
 export declare const POLICY_SEGMENTS: readonly PolicySegment[];
 export declare const POLICY_CHOICE_LABEL: Record<PolicyChoice, string>;

package/dist/customize/connectors/tools/tool-policy-labels.js

@@ -1,37 +1,38 @@
 /**
- * Default · Block · Ask · Allow.
+ * Default · Allow · Ask · Block.
  *
  * FOUR segments, because there are genuinely four states. Default sits first
- * because it is the state every tool starts in, and because the remaining three
- * then read left-to-right as a trust dial: least on the left, most on the right.
+ * because it is the state every tool starts in; the control labels it with
+ * what it resolves to ("Default · runs").
  *
- * Default carries no tint. Inheriting is not a decision, and colouring it would
- * put a fourth hue in every row of a 60-tool connector.
+ * Only Block carries a hue, the destructive token. Allow and Ask are plain
+ * ink: a 60-tool list in three status colours reads as noise, and the word
+ * already says the decision.
  */
 export const POLICY_SEGMENTS = [
     {
         choice: 'default',
         label: 'Default',
-        tint: 'text-muted-foreground',
+        tint: 'text-foreground',
         hoverTint: 'hover:text-foreground',
     },
     {
-        choice: 'block',
-        label: 'Block',
-        tint: 'text-destructive',
-        hoverTint: 'hover:text-destructive',
+        choice: 'always_run',
+        label: 'Allow',
+        tint: 'text-foreground',
+        hoverTint: 'hover:text-foreground',
     },
     {
         choice: 'require_approval',
         label: 'Ask',
-        tint: 'text-kortix-yellow',
-        hoverTint: 'hover:text-kortix-yellow',
+        tint: 'text-foreground',
+        hoverTint: 'hover:text-foreground',
     },
     {
-        choice: 'always_run',
-        label: 'Allow',
-        tint: 'text-kortix-green',
-        hoverTint: 'hover:text-kortix-green',
+        choice: 'block',
+        label: 'Block',
+        tint: 'text-destructive',
+        hoverTint: 'hover:text-destructive',
     },
 ];
 export const POLICY_CHOICE_LABEL = {

package/dist/customize/connectors/tools/tool-policy.d.ts

@@ -1,11 +1,30 @@
-import type { ConnectorEffectivePolicy, ConnectorPolicyAction, ConnectorPolicyRule } from '@kortix/sdk';
+import type { ConnectorAction, ConnectorEffectivePolicy, ConnectorPolicyAction, ConnectorPolicyRule } from '@kortix/sdk';
 export type PolicyChoice = 'default' | ConnectorPolicyAction;
+/**
+ * Which rule list the Tools tab edits: the connector's base rules, or one
+ * policy set. In a set, `'default'` means "inherit": the tool has no rule in
+ * the set, so the base rules decide (`resolveEffectiveAction` checks the set
+ * before the base rules, connectors/policy.ts).
+ */
+export type PolicyScope = 'base' | 'set';
 /**
  * What the control should read for a tool. `risk_default` and `allow_all` are
  * the platform deciding, not the user — showing them as an explicit Allow would
  * claim a choice nobody made, and hide that changing the default moves them.
  */
-export declare function effectiveChoice(path: string, effective: readonly ConnectorEffectivePolicy[]): PolicyChoice;
+export declare function effectiveChoice(path: string, effective: readonly ConnectorEffectivePolicy[], scope?: PolicyScope): PolicyChoice;
+/**
+ * What the Default segment (base rules) or the Inherit segment (a set)
+ * resolves to for one tool, so the control can say it: "Default · runs",
+ * "Inherit · blocked".
+ *
+ * - In a set, the base rules decide an inherited tool: `baseEffective` is the
+ *   server's answer for the base list.
+ * - While the tool is on Default/Inherit, its own `effective` entry is that
+ *   answer too (a pattern rule, the risk default, `allow_all`).
+ * - Otherwise the connector default (`fallback`) decides.
+ */
+export declare function inheritedAction(path: string, choice: PolicyChoice, effective: readonly ConnectorEffectivePolicy[], baseEffective: readonly ConnectorEffectivePolicy[], scope: PolicyScope, fallback: ConnectorPolicyAction): ConnectorPolicyAction;
 /**
  * Project-scope rules are evaluated first and win
  * (`resolveEffectiveAction`, apps/api/src/connectors/policy.ts:342). Editing the
@@ -41,6 +60,11 @@ export declare function applyBulkPolicy(rules: readonly ConnectorPolicyRule[], p
  * explicit regex when slash-wrapped. Everything else is a literal path.
  */
 export declare function isPatternRule(match: string): boolean;
+/**
+ * A rule the per-tool control cannot represent: a pattern, or a rule with
+ * argument conditions. Both live in the Advanced editor.
+ */
+export declare function isAdvancedRule(rule: ConnectorPolicyRule): boolean;
 /**
  * Order a rule set for the wire.
  *
@@ -64,7 +88,7 @@ export declare function orderPolicyRules(rules: readonly ConnectorPolicyRule[]):
  * entirely. Falling back to the stored exact rule keeps the control live in
  * both cases instead of showing every tool as unset.
  */
-export declare function toolChoice(path: string, policies: readonly ConnectorPolicyRule[], effective: readonly ConnectorEffectivePolicy[]): PolicyChoice;
+export declare function toolChoice(path: string, policies: readonly ConnectorPolicyRule[], effective: readonly ConnectorEffectivePolicy[], scope?: PolicyScope): PolicyChoice;
 /**
  * What `effective` will look like once the server applies this change — used
  * to keep an optimistic update honest.
@@ -80,4 +104,26 @@ export declare function toolChoice(path: string, policies: readonly ConnectorPol
  * the server never said. `toolChoice` reads `'default'` from the absence, so
  * the control lands on Default immediately and the refetch fills in the truth.
  */
-export declare function previewEffective(effective: readonly ConnectorEffectivePolicy[], paths: readonly string[], choice: PolicyChoice): ConnectorEffectivePolicy[];
+export declare function previewEffective(effective: readonly ConnectorEffectivePolicy[], paths: readonly string[], choice: PolicyChoice, scope?: PolicyScope): ConnectorEffectivePolicy[];
+export type DefaultMode = 'risk' | 'allow_all';
+/**
+ * What a tool does when no rule names it: the server's default
+ * (`resolveEffectiveAction`, connectors/policy.ts). A sensitive connector asks
+ * for every tool, `allow_all` runs every tool, and otherwise reads run and
+ * writes ask.
+ */
+export declare function connectorDefaultAction(sensitive: boolean, defaultMode: DefaultMode | undefined, risk: ConnectorAction['risk']): ConnectorPolicyAction;
+export interface ToolDecisionSummary {
+    total: number;
+    block: number;
+    ask: number;
+    run: number;
+    /** Tools the list being edited decides itself (not Default/Inherit, not a project rule). */
+    changed: number;
+}
+/**
+ * The counts above the tool list: what each tool does on its next call, and
+ * how many tools this list changes. `effective` is the server's answer and
+ * wins; `fallback` names what a tool with no entry does.
+ */
+export declare function summarizeToolDecisions(actions: readonly ConnectorAction[], policies: readonly ConnectorPolicyRule[], effective: readonly ConnectorEffectivePolicy[], scope: PolicyScope, fallback: (action: ConnectorAction) => ConnectorPolicyAction): ToolDecisionSummary;