@vellumai/assistant 0.9.0-dev.202606182147.d5eebd3 → 0.9.0-dev.202606182338.1cc9a2c

package/openapi.yaml

@@ -16239,6 +16239,7 @@ paths:
                                           - brave
                                           - perplexity
                                           - tavily
+                                          - firecrawl
                                       resultCount:
                                         type: number
                                       durationMs:
@@ -16286,6 +16287,11 @@ paths:
                                         type: string
                                       finalUrl:
                                         type: string
+                                      provider:
+                                        type: string
+                                        enum:
+                                          - default
+                                          - firecrawl
                                       status:
                                         type: number
                                       contentType:
@@ -16621,6 +16627,7 @@ paths:
                                                   - brave
                                                   - perplexity
                                                   - tavily
+                                                  - firecrawl
                                               resultCount:
                                                 type: number
                                               durationMs:
@@ -16668,6 +16675,11 @@ paths:
                                                 type: string
                                               finalUrl:
                                                 type: string
+                                              provider:
+                                                type: string
+                                                enum:
+                                                  - default
+                                                  - firecrawl
                                               status:
                                                 type: number
                                               contentType:
@@ -28733,6 +28745,10 @@ components:
               anyOf:
                 - type: string
                 - type: "null"
+            advisorProfile:
+              anyOf:
+                - type: string
+                - type: "null"
             callSites:
               type: object
               propertyNames:
@@ -28768,6 +28784,16 @@ components:
                       type: string
                   additionalProperties: {}
                 - type: "null"
+            web-fetch:
+              anyOf:
+                - type: object
+                  properties:
+                    mode:
+                      $ref: "#/components/schemas/ServiceMode"
+                    provider:
+                      type: string
+                  additionalProperties: {}
+                - type: "null"
             image-generation:
               anyOf:
                 - type: object
@@ -28963,6 +28989,12 @@ components:
                 - $ref: "#/components/schemas/ProfileStatus"
                 - type: "null"
             - type: "null"
+        advisorEnabled:
+          anyOf:
+            - anyOf:
+                - type: boolean
+                - type: "null"
+            - type: "null"
         mix:
           anyOf:
             - minItems: 2
@@ -29354,6 +29386,8 @@ components:
                 type: string
             activeProfile:
               type: string
+            advisorProfile:
+              type: string
             callSites:
               type: object
               propertyNames:
@@ -29504,6 +29538,14 @@ components:
                 provider:
                   type: string
               additionalProperties: {}
+            web-fetch:
+              type: object
+              properties:
+                mode:
+                  $ref: "#/components/schemas/ServiceMode"
+                provider:
+                  type: string
+              additionalProperties: {}
             image-generation:
               type: object
               properties:
@@ -29653,6 +29695,10 @@ components:
           anyOf:
             - $ref: "#/components/schemas/ProfileStatus"
             - type: "null"
+        advisorEnabled:
+          anyOf:
+            - type: boolean
+            - type: "null"
         mix:
           minItems: 2
           type: array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0-dev.202606182147.d5eebd3",
+  "version": "0.9.0-dev.202606182338.1cc9a2c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -236,7 +236,7 @@ describe("channel inbound disk pressure gate", () => {
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 
-  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+  test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
     upsertContact({
       displayName: "Example Slack User",
       channels: [
@@ -274,18 +274,10 @@ describe("channel inbound disk pressure gate", () => {
       reason: "trusted-contact",
     });
     expect(processMessage).not.toHaveBeenCalled();
-    expect(deliverChannelReplyMock.mock.calls).toEqual([
-      [
-        "https://gateway.test/deliver/slack",
-        {
-          chatId: "slack-channel-1",
-          text: expectedRemoteBlockReply,
-          assistantId: "self",
-          ephemeral: true,
-          user: "slack-user-1",
-        },
-      ],
-    ]);
+    // Reactions are blocked silently during disk pressure: a passive signal
+    // has nothing to "try again", so no block reply is delivered (unlike the
+    // message path, which does reply).
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
 
     const db = getDb();
     const event = db

package/src/__tests__/config-schema.test.ts

@@ -145,6 +145,40 @@ describe("AssistantConfigSchema", () => {
     expect(result.services["web-search"].mode).toBe("your-own");
   });
 
+  test("accepts Firecrawl as a web search provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "web-search": { mode: "your-own", provider: "firecrawl" },
+      },
+    });
+
+    expect(result.services["web-search"].provider).toBe("firecrawl");
+    expect(result.services["web-search"].mode).toBe("your-own");
+  });
+
+  test("defaults the web-fetch provider to the built-in fetcher", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.services["web-fetch"].provider).toBe("default");
+  });
+
+  test("accepts Firecrawl as a web fetch provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "web-fetch": { mode: "your-own", provider: "firecrawl" },
+      },
+    });
+
+    expect(result.services["web-fetch"].provider).toBe("firecrawl");
+  });
+
+  test("rejects an unknown web-fetch provider", () => {
+    expect(() =>
+      AssistantConfigSchema.parse({
+        services: { "web-fetch": { provider: "nope" } },
+      }),
+    ).toThrow();
+  });
+
   test("accepts valid complete config", () => {
     const input = {
       llm: {

package/src/__tests__/credential-security-invariants.test.ts

@@ -158,6 +158,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "credential-execution/prompted-credential.ts", // shared prompt-action persistence (stores secret via setSecureKeyAsync)
       "tools/credentials/broker.ts", // brokered credential access
       "tools/network/web-search.ts", // web search API key lookup
+      "tools/network/web-fetch.ts", // web fetch provider (Firecrawl) API key lookup
       "daemon/handlers/config-telegram.ts", // Telegram bot token management
       "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -25,12 +25,15 @@ import {
   type CanonicalGuardianRequest,
   createCanonicalGuardianDelivery,
   createCanonicalGuardianRequest,
+  getPendingCanonicalRequestByDestinationMessage,
   listCanonicalGuardianDeliveries,
 } from "../memory/canonical-guardian-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-import { recordCanonicalChannelDelivery } from "../notifications/canonical-delivery-recorder.js";
-import type { NotificationDeliveryResult } from "../notifications/types.js";
+import {
+  recordApprovalCardDelivery,
+  recordGuardianRequestDeliveries,
+} from "../notifications/canonical-delivery-recorder.js";
 
 initializeDb();
 
@@ -232,28 +235,161 @@ describe("withdrawGuardianRequestCards", () => {
   });
 });
 
-describe("recordCanonicalChannelDelivery", () => {
+describe("recordApprovalCardDelivery", () => {
   beforeEach(() => {
     resetTables();
-    withdrawSlackApprovalCard.mockClear();
   });
 
-  test("captures the channel-native message id so the card can be withdrawn", async () => {
+  test("records a channel card with its addressing and status", () => {
     const req = makeRequest();
-    const result: NotificationDeliveryResult = {
+    const delivery = recordApprovalCardDelivery({
+      requestId: req.id,
+      channel: "slack",
+      chatId: "C1",
+      messageId: "1700000000.0001",
+      status: "sent",
+    });
+    expect(delivery?.destinationChannel).toBe("slack");
+    expect(delivery?.destinationChatId).toBe("C1");
+    expect(delivery?.destinationMessageId).toBe("1700000000.0001");
+    expect(delivery?.status).toBe("sent");
+  });
+
+  test("records a vellum card addressed by conversation id, defaulting to pending", () => {
+    const req = makeRequest();
+    const delivery = recordApprovalCardDelivery({
+      requestId: req.id,
+      channel: "vellum",
+      conversationId: "conv-x",
+    });
+    expect(delivery?.destinationConversationId).toBe("conv-x");
+    expect(delivery?.destinationChatId).toBeNull();
+    expect(delivery?.status).toBe("pending");
+  });
+
+  test("lets a Slack reaction resolve back to its request (LUM-2502)", () => {
+    // A delivered Slack approval card must be addressable by (channel, chat, ts)
+    // so an emoji reaction on it resolves to the right request rather than
+    // silently falling through to transcript persistence.
+    const req = makeRequest();
+    recordApprovalCardDelivery({
+      requestId: req.id,
       channel: "slack",
-      destination: "C999",
+      chatId: "C-guardian",
+      messageId: "1700000000.5678",
       status: "sent",
-      messageId: "1700000000.1234",
-    };
+    });
+
+    const resolved = getPendingCanonicalRequestByDestinationMessage(
+      "slack",
+      "C-guardian",
+      "1700000000.5678",
+    );
+    expect(resolved?.id).toBe(req.id);
+  });
+});
+
+describe("recordGuardianRequestDeliveries", () => {
+  beforeEach(() => {
+    resetTables();
+    withdrawSlackApprovalCard.mockClear();
+  });
+
+  test("records each delivery with addressing + status and returns the vellum id", () => {
+    const req = makeRequest();
+    const vellumId = recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        {
+          channel: "vellum",
+          destination: "",
+          status: "sent",
+          conversationId: "conv-1",
+        },
+        {
+          channel: "slack",
+          destination: "C999",
+          status: "sent",
+          messageId: "1700000000.1234",
+        },
+      ],
+    });
+
+    const deliveries = listCanonicalGuardianDeliveries(req.id);
+    expect(deliveries).toHaveLength(2);
+    const vellum = deliveries.find((d) => d.destinationChannel === "vellum");
+    const slack = deliveries.find((d) => d.destinationChannel === "slack");
+    expect(vellumId).toBe(vellum?.id);
+    expect(vellum?.destinationConversationId).toBe("conv-1");
+    expect(vellum?.status).toBe("sent");
+    expect(slack?.destinationChatId).toBe("C999");
+    expect(slack?.destinationMessageId).toBe("1700000000.1234");
+    expect(slack?.status).toBe("sent");
+  });
+
+  test("reuses a pre-created vellum row instead of creating a second", () => {
+    const req = makeRequest();
+    const pre = recordApprovalCardDelivery({
+      requestId: req.id,
+      channel: "vellum",
+      conversationId: "conv-1",
+    });
+
+    const vellumId = recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        {
+          channel: "vellum",
+          destination: "",
+          status: "sent",
+          conversationId: "conv-1",
+        },
+      ],
+      vellumDeliveryId: pre?.id,
+    });
+
+    expect(vellumId).toBe(pre?.id);
+    const deliveries = listCanonicalGuardianDeliveries(req.id);
+    expect(deliveries).toHaveLength(1);
+    expect(deliveries[0].status).toBe("sent");
+  });
+
+  test("marks a non-sent delivery result as failed (status now tracked for all producers)", () => {
+    const req = makeRequest();
+    recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        { channel: "slack", destination: "C1", status: "failed" },
+      ],
+    });
+    const [delivery] = listCanonicalGuardianDeliveries(req.id);
+    expect(delivery.status).toBe("failed");
+  });
 
-    const delivery = recordCanonicalChannelDelivery(req.id, result);
+  test("omits chat id when the channel destination is empty", () => {
+    const req = makeRequest();
+    recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [{ channel: "slack", destination: "", status: "sent" }],
+    });
+    const [delivery] = listCanonicalGuardianDeliveries(req.id);
+    expect(delivery.destinationChatId).toBeNull();
+  });
 
-    expect(delivery.destinationChannel).toBe("slack");
-    expect(delivery.destinationChatId).toBe("C999");
-    expect(delivery.destinationMessageId).toBe("1700000000.1234");
+  test("records a Slack delivery the withdrawal path can then edit in place", async () => {
+    const req = makeRequest();
+    recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        {
+          channel: "slack",
+          destination: "C999",
+          status: "sent",
+          messageId: "1700000000.1234",
+        },
+      ],
+    });
 
-    // End-to-end: the recorded delivery is now editable by the withdrawal path.
     await withdrawGuardianRequestCards({
       request: req,
       status: "approved",
@@ -264,15 +400,4 @@ describe("recordCanonicalChannelDelivery", () => {
       "1700000000.1234",
     );
   });
-
-  test("omits chat id when the destination is empty", () => {
-    const req = makeRequest();
-    const delivery = recordCanonicalChannelDelivery(req.id, {
-      channel: "slack",
-      destination: "",
-      status: "sent",
-    });
-    expect(delivery.destinationChatId).toBeNull();
-    expect(listCanonicalGuardianDeliveries(req.id)).toHaveLength(1);
-  });
 });

package/src/__tests__/reaction-persistence.test.ts

@@ -59,7 +59,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import {
   isSlackReactionEvent,
   parseSlackReactionCallbackData,
-} from "../runtime/routes/inbound-message-handler.js";
+} from "../runtime/routes/inbound-stages/reaction-intercept.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
@@ -575,3 +575,112 @@ describe("guardian approval-by-reaction integration via handleChannelInbound", (
     expect(reactionRows.length).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Reaction access-control regression (LUM-2489)
+// ---------------------------------------------------------------------------
+//
+// A reaction is a passive signal, not an access attempt. Because reactions are
+// dispatched before the ingress pipeline, an unknown user's 👍 must never run
+// ACL (no trusted-contact verification handshake), create a conversation, or
+// write a binding — it is dropped as channel noise. A known contact's reaction
+// is recorded; neither triggers a verification challenge.
+
+describe("reaction access control (no verification handshake)", () => {
+  const STRANGER_USER_ID = "U_REACTION_STRANGER";
+  const CONTACT_USER_ID = "U_REACTION_CONTACT";
+  // Guardian's approval channel is a DM, distinct from the public channel the
+  // reaction lands in (mirroring production). Reusing the public channel id
+  // would let a reactor match the guardian's channel via findContactChannel's
+  // externalChatId fallback and mask the bug.
+  const GUARDIAN_DM_CHAT = "D_GUARDIAN_DM";
+
+  function tableCount(table: string): number {
+    return (
+      getDb().$client.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as {
+        n: number;
+      }
+    ).n;
+  }
+
+  beforeEach(() => {
+    resetState();
+    getDb().run("DELETE FROM channel_verification_sessions");
+    // The assistant has a guardian (as in production); the reactors below are
+    // different users.
+    createGuardianBinding({
+      channel: "slack",
+      guardianExternalUserId: GUARDIAN_USER_ID,
+      guardianDeliveryChatId: GUARDIAN_DM_CHAT,
+      guardianPrincipalId: GUARDIAN_USER_ID,
+    });
+    msgCounter = 0;
+  });
+
+  test("stranger's reaction is dropped — no challenge, session, conversation, or row", async () => {
+    let agentDispatched = false;
+    const processMessage = async (): Promise<{ messageId: string }> => {
+      agentDispatched = true;
+      return { messageId: "should-not-be-called" };
+    };
+
+    const req = buildReactionRequest("reaction:thumbsup", {
+      actorExternalId: STRANGER_USER_ID,
+      actorDisplayName: "Outside Reactor",
+      actorUsername: "outsider",
+    });
+    const resp = await handleChannelInbound(
+      req,
+      processMessage,
+      TEST_BEARER_TOKEN,
+    );
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    // Accepted as a passive signal — never denied or turned into a challenge.
+    expect(json.accepted).toBe(true);
+    expect(json.denied).not.toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(json.verificationSessionId).toBeUndefined();
+    expect(agentDispatched).toBe(false);
+
+    // No verification handshake, and no side effects: a dropped reaction leaves
+    // no transcript row, no conversation, and no binding.
+    expect(tableCount("channel_verification_sessions")).toBe(0);
+    expect(readPersistedMessages().length).toBe(0);
+    expect(tableCount("conversations")).toBe(0);
+    expect(tableCount("external_conversation_bindings")).toBe(0);
+  });
+
+  test("known contact's reaction is recorded — no challenge", async () => {
+    // A pending contact classifies as `unverified_contact` — a known tier, so
+    // its reactions are recorded. On a real message it would be re-challenged,
+    // but a reaction must not trigger that.
+    upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: CONTACT_USER_ID,
+      externalChatId: SLACK_CHANNEL_ID,
+      status: "pending",
+      policy: "allow",
+      displayName: "Pending Contact",
+    });
+
+    const req = buildReactionRequest("reaction:tada", {
+      actorExternalId: CONTACT_USER_ID,
+      actorDisplayName: "Pending Contact",
+      actorUsername: "pending_contact",
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.denied).not.toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(tableCount("channel_verification_sessions")).toBe(0);
+
+    const rows = readPersistedMessages();
+    expect(rows.length).toBe(1);
+    const envelope = JSON.parse(rows[0].metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(envelope.slackMeta as string);
+    expect(slackMeta?.eventKind).toBe("reaction");
+    expect(slackMeta?.reaction?.emoji).toBe("tada");
+  });
+});

package/src/api/events/tool-result.ts

@@ -47,10 +47,15 @@ export const WebSearchProviderIdSchema = z.enum([
   "brave",
   "perplexity",
   "tavily",
+  "firecrawl",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
 
+export const WebFetchProviderIdSchema = z.enum(["default", "firecrawl"]);
+
+export type WebFetchProviderId = z.infer<typeof WebFetchProviderIdSchema>;
+
 export const WebSearchResultItemSchema = z.object({
   rank: z.number(),
   title: z.string(),
@@ -78,6 +83,7 @@ export type WebSearchMetadata = z.infer<typeof WebSearchMetadataSchema>;
 export const WebFetchMetadataSchema = z.object({
   url: z.string(),
   finalUrl: z.string(),
+  provider: WebFetchProviderIdSchema.optional(),
   status: z.number(),
   contentType: z.string().optional(),
   byteCount: z.number(),

package/src/calls/guardian-dispatch.ts

@@ -9,15 +9,15 @@
 
 import { findGuardianForChannel } from "../contacts/contact-store.js";
 import {
-  createCanonicalGuardianDelivery,
   createCanonicalGuardianRequest,
   listCanonicalGuardianDeliveries,
   listCanonicalGuardianRequests,
-  updateCanonicalGuardianDelivery,
 } from "../memory/canonical-guardian-store.js";
-import { recordCanonicalChannelDelivery } from "../notifications/canonical-delivery-recorder.js";
+import {
+  recordApprovalCardDelivery,
+  recordGuardianRequestDeliveries,
+} from "../notifications/canonical-delivery-recorder.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
-import type { NotificationDeliveryResult } from "../notifications/types.js";
 import { getLogger } from "../util/logger.js";
 import { getUserConsultationTimeoutMs } from "./call-constants.js";
 import type { CallPendingQuestion } from "./types.js";
@@ -40,17 +40,6 @@ export interface GuardianDispatchParams {
   inputDigest?: string;
 }
 
-function applyDeliveryStatus(
-  deliveryId: string,
-  result: NotificationDeliveryResult,
-): void {
-  if (result.status === "sent") {
-    updateCanonicalGuardianDelivery(deliveryId, { status: "sent" });
-    return;
-  }
-  updateCanonicalGuardianDelivery(deliveryId, { status: "failed" });
-}
-
 /**
  * Dispatch a guardian action request to all configured channels.
  * Fire-and-forget: errors are logged but do not propagate.
@@ -180,7 +169,7 @@ async function dispatchGuardianQuestionInner(
 
     // Route through the canonical notification pipeline. The paired vellum
     // conversation from this pipeline is the canonical guardian conversation.
-    let vellumDeliveryId: string | null = null;
+    let vellumDeliveryId: string | undefined;
     const requestCode =
       request.requestCode ?? request.id.slice(0, 6).toUpperCase();
     const signalResult = await emitNotificationSignal({
@@ -209,39 +198,26 @@ async function dispatchGuardianQuestionInner(
       onConversationCreated: (info) => {
         if (info.sourceEventName !== "guardian.question" || vellumDeliveryId)
           return;
-        const delivery = createCanonicalGuardianDelivery({
+        vellumDeliveryId = recordApprovalCardDelivery({
           requestId: request.id,
-          destinationChannel: "vellum",
-          destinationConversationId: info.conversationId,
-        });
-        vellumDeliveryId = delivery.id;
+          channel: "vellum",
+          conversationId: info.conversationId,
+        })?.id;
       },
     });
 
-    for (const result of signalResult.deliveryResults) {
-      if (result.channel === "vellum") {
-        if (!vellumDeliveryId) {
-          const delivery = createCanonicalGuardianDelivery({
-            requestId: request.id,
-            destinationChannel: "vellum",
-            destinationConversationId: result.conversationId,
-          });
-          vellumDeliveryId = delivery.id;
-        }
-        applyDeliveryStatus(vellumDeliveryId, result);
-        continue;
-      }
-
-      const delivery = recordCanonicalChannelDelivery(request.id, result);
-      applyDeliveryStatus(delivery.id, result);
-    }
+    vellumDeliveryId = recordGuardianRequestDeliveries({
+      requestId: request.id,
+      deliveryResults: signalResult.deliveryResults,
+      vellumDeliveryId,
+    });
 
     if (!vellumDeliveryId) {
-      const fallback = createCanonicalGuardianDelivery({
+      recordApprovalCardDelivery({
         requestId: request.id,
-        destinationChannel: "vellum",
+        channel: "vellum",
+        status: "failed",
       });
-      updateCanonicalGuardianDelivery(fallback.id, { status: "failed" });
       log.warn(
         { requestId: request.id, reason: signalResult.reason },
         "Notification pipeline did not produce a vellum delivery result",

package/src/config/call-site-defaults.ts

@@ -69,6 +69,9 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   meetConsentMonitor: { profile: "cost-optimized" },
   meetChatOpportunity: { profile: "cost-optimized" },
   inference: { profile: "cost-optimized" },
+  // The advisor consults the strongest managed profile by default; a workspace
+  // overrides this via `llm.advisorProfile` (which floats above this).
+  advisor: { profile: "quality-optimized" },
 
   heartbeatAgent: {
     profile: "cost-optimized",

package/src/config/llm-resolver.ts

@@ -366,6 +366,9 @@ function profileConfigFragment(profile: ProfileEntry): Mergeable {
     // lower-precedence (e.g. active) profile into one that merely inherited it.
     // `RetryProvider` resolves it from the applied profile, not the merge.
     logitBias: _logitBias,
+    // Per-profile advisor toggle is profile identity, not inheritable model
+    // config — strip it so it can't leak into the merged `LLMConfigBase`.
+    advisorEnabled: _advisorEnabled,
     ...config
   } = profile;
   return config as Mergeable;