mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-20 18:26:40 +01:00
## Thinking Path
> - Paperclip is the open source app people use to manage AI agents for
work
> - Agents act through Paperclip tools. The runner shows each tool to
the model with an input schema and checks every call against that schema
before it runs
> - Some tool schemas had a root `oneOf`, `anyOf`, `allOf` or
`if`/`then`. `handoff_case` had no top-level `properties` at all
> - Some model hosts convert such a schema into an empty argument list.
The model then calls the tool with no arguments, and the runner rejects
the call as "Invalid tool input"
> - The repeated-failure guard from #21360 does not see these
rejections, because they happen in the runner before the call reaches
the control plane. The model sent the same rejected call again and again
> - This pull request gives every agent-facing tool a plain object
schema with named properties, checks the old cross-field rules with
named errors, and adds a runner-side guard for identical "Invalid tool
input" rejections
> - The benefit is that models on these hosts can see and send the
arguments, and a dropped argument ends in a clear correction or a stop,
not a long loop
## Linked Issues or Issue Description
**What happened?**
In a chat eval cohort with OpenCode and
`openrouter/deepseek/deepseek-v4.1-flash-1017`, the hosts Wafer and
DigitalOcean served most model calls. In the case handoff case,
`handoff_case` arrived with no arguments on all 10 calls across two
cases. The runner rejected each one with "must have required property
idempotencyKey, case, toAgentId, ...". The model's reasoning said that
the tool showed an empty property list. The model fell back to
`call_api`, but the reply waiter had already expired, so the case
failed. In the preserve-draft case, `request_human_input` was rejected 9
times in a row with the same root `then` error.
**Expected behavior**
Every tool that an agent sees has a plain object schema with named
properties, so every host can show its arguments. When the same call is
rejected twice with the same arguments, the model gets a correction that
lists the expected properties. On the third identical call, the model is
told to change the arguments or stop.
**Paperclip version or commit**
`master` at f7ddab8e94.
**Steps to reproduce**
1. Run an OpenCode agent with
`openrouter/deepseek/deepseek-v4.1-flash-1017`, where OpenRouter routes
to Wafer or DigitalOcean.
2. Ask the agent to hand a case to another agent with `handoff_case`.
3. See `handoff_case` arrive with no arguments and get rejected on every
call.
## What Changed
- Add `providerToolSchemaShapeIssues`
(`packages/paperclip-runner/src/contracts/provider-tool-schema-shape.ts`).
It reports a root that is not `type: "object"`, has no `properties`, or
uses `oneOf`, `anyOf`, `allOf`, `not`, `if`, `then`, `else`,
`dependent*` or `$ref`.
- Add inventory tests that run this check on every agent-facing tool:
the live semantic catalog, the semantic action catalog, the Codex tool
specs, `paperclip_finish` and `paperclip_block` (runner), and the
server-only tool definitions (server). Before this change, the runner
test listed 16 entries for 8 tools: `handoff_case`,
`request_human_input`, `read_case`, `update_case`, `create_case`,
`read_workflow`, `update_workflow` and `paperclip_finish`.
- Flatten these 8 schemas. `handoff_case` is now one object with `to`
(optional, `"done"`), and `case` is one object with optional `id` and
`create`. Descriptions on the properties state which fields each variant
needs.
- Add `toolInputVariantError`
(`packages/paperclip-runner/src/contracts/tool-input-variants.ts`). It
checks the former cross-field rules and returns an error that names what
is wrong and how to send the call correctly. For example: `Invalid tool
input for handoff_case: An agent handoff requires toAgentId, phase. To
finish an existing case instead, send to: "done" with
expectedHandoffVersion and expectedIssueStatusVersion.`
- The server runs this check first in
`PaperclipRunnerToolAuthority.execute` and returns `422`. The #21360
guard therefore counts these errors too. Assigned MCP tools and
connector tools are not checked. The runner semantic dispatchers run the
same check after schema validation. The runner MCP bridges run it for
`paperclip_finish`, which never reaches the control plane.
- Add `RepeatedToolInputRejectionGuard`
(`packages/paperclip-runner/src/drivers/repeated-tool-input-rejection.ts`)
and use it in the OpenCode MCP bridge and the runner tool bridge, where
runner-side validation happens. The key is the tool, the canonical
arguments and the error text, separated per MCP session. The second
identical rejection adds the arguments that arrived and the expected
required and optional properties. The third and later identical calls
say that the call was not accepted and that the model must change the
arguments or stop and report the blocker. State is in memory, per
bridge, and capped at 64 entries.
- Regenerate `semantic-tool-contracts.json`,
`semantic-action-catalog.json`, `protocol/manifest.json` and the seeded
eval fixture.
- Add `spec/fixtures/pre-flat-tool-input-schemas.json`: the 8 strict
schemas from the previous release, for the upgrade test.
## Verification
- `cd packages/paperclip-runner && npx vitest run src/contracts
src/catalog src/protocol-actions src/semantic-tools
src/drivers/opencode/mcp-bridge.test.ts
src/drivers/runner-tool-bridge.test.ts`: all pass.
- `cd server && npx vitest run
src/services/native-runtime/tool-input-variant-admission.test.ts
src/services/native-runtime/repeated-tool-failure-guard.test.ts`: 9
passed.
- Red/green:
- The runner inventory test fails on `master` and lists the 16 entries.
It passes after the change.
- The guard test replays the recorded empty `handoff_case` call 4 times
through the real OpenCode bridge. Without the guard, the second call has
no correction and the test fails. With the guard, the second call lists
`required idempotencyKey, case, instructions; optional to, toAgentId,
phase, ...`, and the third says the call was not accepted.
- Negative controls: changed arguments get a fresh error, and a valid
call still runs once.
- Upgrade safety: `tool-input-variants.test.ts` compiles the previous
release's strict schemas from the fixture. For a corpus of valid and
invalid inputs per tool (27 for `handoff_case`), it checks that "flat
schema accepts and `toolInputVariantError` is null" gives exactly the
same result as the old schema. Each tool has accepted and rejected
inputs.
- Generated outputs: `check:semantic-contracts`,
`check:capability-contract`, `check:protocol-coverage`,
`check:capability-inventory`, `check:protocol-manifest` and the replay
golden check pass.
- Rust tests that read the generated contract: see the CI `runner`
checks.
- Paid narrow run: see the comment below.
## Risks
- Previous-release story: tool schemas are not saved run identity. The
OpenCode bridge lists tools again when a session resumes. A durable Rust
run that is already attached keeps the tool catalog it saved, because
re-attaching the same run does not replace the catalog. Every input the
old strict schemas accepted is still accepted, and every input they
rejected is still rejected, so saved calls, receipts and replays carry
forward. No session is reset, and no profile version or provider
`commandDigest` changes. The pack `contractDigest` changes because
`generated/` changed, as it does for any tool contract change.
- A rejected variant now arrives later for the semantic tools: the
server returns `422` instead of the runner bridge rejecting it. The
error text names the problem.
- For `paperclip_finish` on Codex, the advertised schema no longer has
the root conditional. The Rust bridge accepts a `done` result with a
continuation object, and canonical result validation still rejects it,
as before.
- Latency: the advertised schemas of the 8 tools are 1,876 bytes smaller
(23,785 to 21,909), about 470 fewer prompt tokens when all are listed.
Compiling their validators in the bridge takes 164 ms instead of 214 ms
(median of 15). The guard adds one SHA-256 of the canonical arguments
for each rejected call only. Nothing is added before turn start.
## Model Used
- Claude (Anthropic), model ID `claude-opus-5-5`, used through Claude
Code with tool use and code execution.
## Checklist
- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
992 lines
44 KiB
TypeScript
992 lines
44 KiB
TypeScript
import { Ajv2020 } from "ajv/dist/2020.js";
|
|
import { requestHumanInputAction } from "../../../packages/paperclip-runner/src/protocol-actions/request-human-input.js";
|
|
import { toolInputVariantError } from "../../../packages/paperclip-runner/src/contracts/tool-input-variants.js";
|
|
import { questionSetToAskUserQuestionsPayload } from "@paperclipai/shared";
|
|
import { randomUUID } from "node:crypto";
|
|
import { eq } from "drizzle-orm";
|
|
import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
|
|
import {
|
|
agents,
|
|
authUsers,
|
|
companies,
|
|
companyMemberships,
|
|
goals,
|
|
heartbeatRuns,
|
|
issueThreadInteractions,
|
|
issueComments,
|
|
issues,
|
|
createDb,
|
|
toolApplications,
|
|
toolConnections,
|
|
connectionGrants,
|
|
toolCatalogEntries,
|
|
toolProfiles,
|
|
toolProfileBindings,
|
|
toolConnectionInstalls,
|
|
} from "@paperclipai/db";
|
|
import type { RuntimeToolsTokenClaims } from "../runtime-tools-token.js";
|
|
import { connectionIntentService } from "../services/connection-intents.js";
|
|
import { instanceSettingsService } from "../services/instance-settings.js";
|
|
import { issueThreadInteractionService } from "../services/issue-thread-interactions.js";
|
|
import {
|
|
getEmbeddedPostgresTestSupport,
|
|
startEmbeddedPostgresTestDatabase,
|
|
} from "./helpers/embedded-postgres.js";
|
|
const support = await getEmbeddedPostgresTestSupport();
|
|
(support.supported ? describe : describe.skip)(
|
|
"aggregator connection fallback",
|
|
() => {
|
|
let db!: ReturnType<typeof createDb>;
|
|
let connectionString!: string;
|
|
let cleanup: (() => Promise<void>) | undefined;
|
|
let claims!: RuntimeToolsTokenClaims;
|
|
let runId!: string;
|
|
beforeAll(async () => {
|
|
const tempDb = await startEmbeddedPostgresTestDatabase(
|
|
"paperclip-connection-intents-",
|
|
);
|
|
cleanup = tempDb.cleanup;
|
|
connectionString = tempDb.connectionString;
|
|
db = createDb(connectionString);
|
|
const companyId = randomUUID();
|
|
const agentId = randomUUID();
|
|
const goalId = randomUUID();
|
|
const issueId = randomUUID();
|
|
runId = randomUUID();
|
|
await db.insert(companies).values({
|
|
id: companyId,
|
|
name: "Connection tests",
|
|
issuePrefix: "AGG",
|
|
requireBoardApprovalForNewAgents: false,
|
|
});
|
|
await db.insert(authUsers).values({
|
|
id: "responsible-user", name: "Responsible user", email: "responsible-user@example.test",
|
|
createdAt: new Date(), updatedAt: new Date(),
|
|
});
|
|
await db.insert(companyMemberships).values({
|
|
companyId,
|
|
principalType: "user",
|
|
principalId: "responsible-user",
|
|
status: "active",
|
|
membershipRole: "member",
|
|
});
|
|
await db.insert(goals).values({
|
|
id: goalId,
|
|
companyId,
|
|
title: "Connect a service",
|
|
level: "task",
|
|
status: "active",
|
|
});
|
|
await db.insert(agents).values({
|
|
id: agentId,
|
|
companyId,
|
|
name: "Researcher",
|
|
role: "researcher",
|
|
status: "active",
|
|
adapterType: "codex_local",
|
|
adapterConfig: {},
|
|
runtimeConfig: {},
|
|
permissions: {},
|
|
});
|
|
await db.insert(issues).values({
|
|
id: issueId,
|
|
companyId,
|
|
goalId,
|
|
title: "Read Notion",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
assigneeAgentId: agentId,
|
|
});
|
|
await db.insert(heartbeatRuns).values({
|
|
id: runId,
|
|
companyId,
|
|
agentId,
|
|
status: "running",
|
|
responsibleUserId: "responsible-user",
|
|
contextSnapshot: { issueId },
|
|
});
|
|
claims = {
|
|
sub: agentId,
|
|
company_id: companyId,
|
|
run_id: runId,
|
|
responsible_user_id: "responsible-user",
|
|
scope: "connection_intents",
|
|
iat: 1,
|
|
exp: 2,
|
|
instance_id: "test",
|
|
};
|
|
}, 60_000);
|
|
|
|
afterAll(async () => {
|
|
await cleanup?.();
|
|
});
|
|
|
|
async function userRequest(body: string, userId = "responsible-user") {
|
|
const [run] = await db
|
|
.select()
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
await db
|
|
.insert(issueComments)
|
|
.values({
|
|
companyId: claims.company_id,
|
|
issueId: run!.contextSnapshot!.issueId as string,
|
|
authorUserId: userId,
|
|
body,
|
|
});
|
|
}
|
|
async function resetQuestions() {
|
|
await db
|
|
.delete(issueComments)
|
|
.where(eq(issueComments.companyId, claims.company_id));
|
|
await db
|
|
.delete(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.companyId, claims.company_id));
|
|
await db
|
|
.delete(toolConnections)
|
|
.where(eq(toolConnections.companyId, claims.company_id));
|
|
await db
|
|
.delete(toolProfiles)
|
|
.where(eq(toolProfiles.companyId, claims.company_id));
|
|
await db
|
|
.delete(toolApplications)
|
|
.where(eq(toolApplications.companyId, claims.company_id));
|
|
}
|
|
async function selectProvider(
|
|
option: string,
|
|
userId = "responsible-user",
|
|
query = "hubspot",
|
|
) {
|
|
const result = await connectionIntentService(db).search(claims, query);
|
|
const [run] = await db
|
|
.select()
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
const issue = {
|
|
id: run!.contextSnapshot!.issueId as string,
|
|
companyId: claims.company_id,
|
|
};
|
|
const interaction = await issueThreadInteractionService(db).create(
|
|
issue,
|
|
{
|
|
kind: "ask_user_questions",
|
|
payload: { version: 1, questions: [result.providerQuestion!] },
|
|
sourceRunId: runId,
|
|
addresseeUserId: "responsible-user",
|
|
},
|
|
{ agentId: claims.sub, runId },
|
|
);
|
|
// Public resolution service enforces human answer semantics; company membership
|
|
// and wrong-identity request checks are also exercised below.
|
|
await issueThreadInteractionService(db).answerQuestions(
|
|
issue,
|
|
interaction.id,
|
|
{
|
|
answers: [
|
|
{ questionId: result.providerQuestion!.id, optionIds: [option] },
|
|
],
|
|
},
|
|
{ userId },
|
|
);
|
|
return interaction;
|
|
}
|
|
async function seedProvider(
|
|
provider: string,
|
|
toolName: string,
|
|
userId = "responsible-user",
|
|
allowed = true,
|
|
) {
|
|
const [app] = await db
|
|
.insert(toolApplications)
|
|
.values({
|
|
companyId: claims.company_id,
|
|
applicationKey: randomUUID(),
|
|
name: provider,
|
|
type: "mcp_http",
|
|
status: "active",
|
|
metadata: { sourceTemplateKey: provider },
|
|
})
|
|
.returning();
|
|
const [connection] = await db
|
|
.insert(toolConnections)
|
|
.values({
|
|
companyId: claims.company_id,
|
|
applicationId: app!.id,
|
|
uid: randomUUID(),
|
|
name: provider,
|
|
transport: "mcp_remote",
|
|
authKind: "none",
|
|
credentialPolicy: "per_user",
|
|
status: "active",
|
|
enabled: true,
|
|
healthStatus: "ok",
|
|
config: { sourceTemplateKey: provider },
|
|
})
|
|
.returning();
|
|
await db.insert(connectionGrants).values({
|
|
companyId: claims.company_id,
|
|
connectionId: connection!.id,
|
|
kind: "user",
|
|
subjectUserId: userId,
|
|
status: "active",
|
|
});
|
|
await db.insert(toolCatalogEntries).values({
|
|
companyId: claims.company_id,
|
|
connectionId: connection!.id,
|
|
toolName,
|
|
name: toolName,
|
|
versionHash: "fixture",
|
|
status: "active",
|
|
entryKind: "tool",
|
|
lastSeenAt: new Date("2026-09-20T00:00:00Z"),
|
|
});
|
|
await db.insert(toolConnectionInstalls).values({
|
|
companyId: claims.company_id,
|
|
connectionId: connection!.id,
|
|
targetType: "agent",
|
|
targetId: claims.sub,
|
|
});
|
|
if (allowed) {
|
|
const [profile] = await db
|
|
.insert(toolProfiles)
|
|
.values({
|
|
companyId: claims.company_id,
|
|
profileKey: randomUUID(),
|
|
name: "Fixture reads",
|
|
defaultAction: "allow",
|
|
status: "active",
|
|
})
|
|
.returning();
|
|
await db.insert(toolProfileBindings).values({
|
|
companyId: claims.company_id,
|
|
profileId: profile!.id,
|
|
targetType: "agent",
|
|
targetId: claims.sub,
|
|
});
|
|
}
|
|
return connection!;
|
|
}
|
|
it.each([
|
|
["AgentMail create an email address and manage an agent mailbox", "agentmail"],
|
|
["Please acquire an email address through agent mail and remember it", "agentmail"],
|
|
["I need an Agentmial inbox for receiving mail from customers", "agentmail"],
|
|
["Please connect my Linear workspace so I can triage the team's backlog", "linear"],
|
|
["Find a Notion connection to search our engineering documentation", "notion"],
|
|
["Can you find the OpenRouter connection for the model I want to use?", "openrouter"],
|
|
["Please help me connect to Git Hub to look at my pull requests", "github"],
|
|
])("finds native connections in natural-language queries: %s", async (query, service) => {
|
|
await resetQuestions();
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: true });
|
|
try {
|
|
const result = await connectionIntentService(db).search(claims, query);
|
|
expect(result.results[0]).toMatchObject({ service, state: "available" });
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
} finally {
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: false });
|
|
}
|
|
});
|
|
it.each([false, true])("discovers AgentMail with truthful setup actions regardless of the chat setting (%s)", async (enabled) => {
|
|
await resetQuestions();
|
|
const service = connectionIntentService(db);
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: enabled });
|
|
try {
|
|
const result = await service.search(claims, "agentmail");
|
|
expect(result.results[0]?.methods).toEqual([expect.objectContaining({
|
|
key: "email-agent", purpose: "channel", setupPath: `/AGG/apps/chat/connect?provider=agentmail&purpose=chat&agentId=${claims.sub}`,
|
|
})]);
|
|
expect(result.instruction).toContain("connection_request");
|
|
const requested = await service.request(claims, "agentmail");
|
|
expect(requested).toMatchObject({ state: "needs_user_action", interactionId: expect.any(String) });
|
|
expect(await service.request(claims, "agentmail")).toMatchObject({ interactionId: requested.interactionId });
|
|
const options = await service.setupOptions(requested.interactionId!);
|
|
expect(options.interaction.payload).toMatchObject({ purpose: "channel", serviceSlug: "agentmail", requestingAgentId: claims.sub });
|
|
expect(options.emailSetup).toEqual({ credentialConnectionId: null, readyConnectionId: null });
|
|
await service.decline(requested.interactionId!, "responsible-user");
|
|
await expect(service.request(claims, "agentmail")).rejects.toThrow(/already been resolved/);
|
|
const browse = await service.search(claims, "");
|
|
expect(browse.results.some(item => item.service === "agentmail")).toBe(true);
|
|
expect(browse.results.some(item => item.service === "anthropic")).toBe(true);
|
|
} finally {
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: false });
|
|
}
|
|
});
|
|
it("keeps useful capability matches even when other query words do not occur in the catalog", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims,
|
|
"I need something that can search documents and spreadsheets for our quarterly planning discussion");
|
|
expect(result.results.some(item => item.service === "google-drive")).toBe(true);
|
|
expect(result.results.some(item => item.service === "google-sheets")).toBe(true);
|
|
expect(result.instruction).not.toContain("search its exact name");
|
|
});
|
|
it("keeps installed capability matches when a generic query resembles an external app name", async () => {
|
|
await resetQuestions();
|
|
const installed = await seedProvider("Studio library", "notion:list_pages");
|
|
await db.update(toolCatalogEntries).set({ description: "Read recent pages and return their titles and verification code" })
|
|
.where(eq(toolCatalogEntries.connectionId, installed.id));
|
|
const service = connectionIntentService(db);
|
|
const result = await service.search(claims,
|
|
"connected page service that can find or list recent pages and return page titles plus a verification code");
|
|
expect(result.results).toEqual(expect.arrayContaining([expect.objectContaining({
|
|
service: `connection:${installed.id}`, connectionId: installed.id, state: "ready",
|
|
})]));
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).not.toContain("Ask the responsible user with providerQuestion");
|
|
// A deliberate app name still reaches the existing governed provider choice.
|
|
const named = await service.search(claims, "Page X");
|
|
expect(named.providerQuestion?.id).toBe("connection-provider:page-x");
|
|
expect(named.results[0]?.service).toBe("via:composio:page-x");
|
|
});
|
|
it("keeps an external typo as a discovery suggestion until its app is selected", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims,
|
|
"Find Fathm meeting transcripts and action items from yesterday");
|
|
expect(result.results.some(item => item.service === "via:composio:fathom")).toBe(true);
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("aggregator.targetService");
|
|
});
|
|
it.each([
|
|
["help me find tools for otter ai", "otter-ai-mcp"],
|
|
["Can you connect Fathom to get all our meeting notes?", "fathom"],
|
|
["Find Attio tools to review all our customer contacts before next week's meeting", "attio"],
|
|
["Help me find a ClickUp connection to organize our team's projects", "clickup"],
|
|
])("finds verified aggregator apps in natural-language queries: %s", async (query, target) => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, query);
|
|
expect(result.results).toEqual(expect.arrayContaining([expect.objectContaining({
|
|
service: `via:composio:${target}`, source: "aggregator",
|
|
aggregator: expect.objectContaining({ evidenceUrl: expect.stringContaining("composio.dev/"), targetService: target }),
|
|
})]));
|
|
expect(result.providerQuestion?.options.map(option => option.id)).toContain(`via:composio:${target}`);
|
|
await expect(connectionIntentService(db).request(claims, `via:composio:${target}`)).rejects.toThrow();
|
|
});
|
|
it.each([false, true])("prefers an exact Motion match over fuzzy Notion (Notion denied: %s)", async denied => {
|
|
await resetQuestions();
|
|
if (denied) await seedProvider("notion", "notion_search", "responsible-user", false);
|
|
const result = await connectionIntentService(db).search(claims, "Help me find Motion tools");
|
|
expect(result.results[0]?.service).toBe("via:composio:motion");
|
|
expect(result.providerQuestion?.id).toBe("connection-provider:motion");
|
|
expect(result.instruction).not.toContain("administratively restricted");
|
|
});
|
|
it("finds namespaced installed aggregator tools with extra query words", async () => {
|
|
await resetQuestions();
|
|
await seedProvider("executor", "heliotrope:list_records");
|
|
const result = await connectionIntentService(db).search(claims, "Please find heliotrope tools for our weekly report");
|
|
expect(result.results[0]?.service).toBe("via:executor:heliotrope");
|
|
});
|
|
it("returns multiple named services so the agent can choose the relevant result", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "Find Linear or Notion for our project planning");
|
|
expect(result.results.map(item => item.service)).toEqual(expect.arrayContaining(["linear", "notion"]));
|
|
});
|
|
it("returns multiple aggregator apps without inventing a combined route or choosing consent", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "Find Fathom and Attio tools");
|
|
expect(result.results.map(item => item.service)).toEqual(expect.arrayContaining(["via:composio:fathom", "via:composio:attio"]));
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("aggregator.targetService");
|
|
});
|
|
it("keeps native and aggregator app matches from the same query", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "Find Notion and Fathom tools");
|
|
expect(result.results.map(item => item.service)).toEqual(expect.arrayContaining(["notion", "via:composio:fathom"]));
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
});
|
|
|
|
// Composio lists Circleback too (circleback_mcp), but with fewer tools and no
|
|
// meeting cards; the built-in connection answers these requests directly.
|
|
it.each([
|
|
"help me find tools for circle back",
|
|
"Can you connect Circleback MCP to get all our meeting notes?",
|
|
"Find Circleback meeting transcripts and action items from yesterday",
|
|
])("prefers the built-in Circleback connection over its aggregator listing: %s", async (query) => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, query);
|
|
expect(result.results[0]?.service).toBe("circleback");
|
|
expect(result.results.some(item => item.service.startsWith("via:"))).toBe(false);
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("connection_request");
|
|
});
|
|
it("prefers the built-in Jira connection and returns a direct instruction", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"atlassian jira",
|
|
);
|
|
expect(result.results[0]?.service).toBe("jira");
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("connection_request");
|
|
});
|
|
// BUG-06: on Paperclip Cloud, the native Slack tool path requires a customer-created
|
|
// Slack OAuth app and managed Slack chat setup is behind the Chat connectors opt-in.
|
|
// Agents must offer the one-click aggregator routes instead of that card.
|
|
describe("Slack on Paperclip Cloud", () => {
|
|
const slackQuery = "Slack (team updates / notifications)";
|
|
beforeAll(() => { vi.stubEnv("PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN", "cloud-test-token"); });
|
|
afterAll(() => { vi.unstubAllEnvs(); });
|
|
it("offers aggregator Slack routes while native Slack only supports a customer-created OAuth app", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, slackQuery);
|
|
expect(result.results.map((item) => item.service)).toEqual([
|
|
"via:composio:slack",
|
|
"via:arcade:slack",
|
|
"via:zapier:slack",
|
|
]);
|
|
expect(result.providerQuestion?.prompt).toContain("Slack");
|
|
});
|
|
it("keeps native Slack when Chat connectors provide its own setup path", async () => {
|
|
await resetQuestions();
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: true });
|
|
try {
|
|
const result = await connectionIntentService(db).search(claims, slackQuery);
|
|
expect(result.results[0]).toMatchObject({ service: "slack", state: "available" });
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
} finally {
|
|
await instanceSettingsService(db).updateExperimental({ enableChatConnectors: false });
|
|
}
|
|
});
|
|
it("does not offer native Slack setup beside another app's native match", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "Find Notion and Slack tools");
|
|
const services = result.results.map((item) => item.service);
|
|
expect(services).toEqual(expect.arrayContaining(["notion", "via:composio:slack"]));
|
|
expect(services).not.toContain("slack");
|
|
});
|
|
it("keeps Slack's aggregator routes in capability-only discovery", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "start and continue Paperclip work");
|
|
const services = result.results.map((item) => item.service);
|
|
expect(services).toContain("via:composio:slack");
|
|
expect(services).not.toContain("slack");
|
|
// A route needs the provider-choice flow before connection_request.
|
|
expect(result.instruction).toContain("search its aggregator.targetService");
|
|
});
|
|
it("keeps native connectors that declare a Paperclip Cloud managed method", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "asana");
|
|
expect(result.results[0]).toMatchObject({ service: "asana" });
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
});
|
|
it("keeps native Slack for a company that already saved a Slack connection", async () => {
|
|
await resetQuestions();
|
|
await seedProvider("slack", "slack_send_message");
|
|
const result = await connectionIntentService(db).search(claims, slackQuery);
|
|
expect(result.results[0]).toMatchObject({ service: "slack" });
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
});
|
|
});
|
|
it("keeps native Slack on self-hosted instances, where operators register their own Slack app", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "Slack (team updates / notifications)");
|
|
expect(result.results[0]).toMatchObject({ service: "slack", state: "available" });
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
});
|
|
it("returns ranked verified routes and does not create questions or connections during search", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"HubSpot recent contacts",
|
|
);
|
|
expect(result.results.map((item) => item.service)).toEqual([
|
|
"via:composio:hubspot",
|
|
"via:arcade:hubspot",
|
|
"via:zapier:hubspot",
|
|
]);
|
|
expect(result.providerQuestion?.prompt).toContain("external service");
|
|
const ajv = new Ajv2020({ allErrors: true, allowUnionTypes: true, strict: false });
|
|
const input = { idempotencyKey: "provider-choice", interactionKind: "questions", title: "Choose a provider",
|
|
prompt: result.providerQuestion!.prompt, continuationPolicy: "wake_assignee" };
|
|
for (const payload of [{ version: 1, questionSet: result.providerQuestionSet }, { version: 1, questions: [result.providerQuestion] }]) {
|
|
expect(ajv.validate(requestHumanInputAction.live.descriptor.inputSchema, { ...input, payload }), JSON.stringify(ajv.errors)).toBe(true);
|
|
}
|
|
expect(questionSetToAskUserQuestionsPayload(result.providerQuestionSet!).questions).toEqual([result.providerQuestion]);
|
|
expect(result.instruction).toContain("questionSet:providerQuestionSet");
|
|
expect(result.instruction).not.toContain("do not add questionSet");
|
|
// The advertised schema is a plain object; the questions rule is a server-checked variant.
|
|
expect(ajv.validate(requestHumanInputAction.live.descriptor.inputSchema, { ...input, payload: { version: 1 } })
|
|
&& toolInputVariantError("request_human_input", { ...input, payload: { version: 1 } }) === null).toBe(false);
|
|
expect(ajv.validate(requestHumanInputAction.live.descriptor.inputSchema, { ...input, payload: { version: 1,
|
|
questionSet: { ...result.providerQuestionSet, questions: [{ ...result.providerQuestionSet!.questions[0], answerMode: "text" }] } } })).toBe(false);
|
|
expect(result.results.every((item) => item.state !== "ready")).toBe(true);
|
|
expect(result.results.every((item) => item.aggregator?.evidenceUrl)).toBe(
|
|
true,
|
|
);
|
|
expect(
|
|
await db
|
|
.select()
|
|
.from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.companyId, claims.company_id)),
|
|
).toHaveLength(0);
|
|
});
|
|
it("requires a real saved provider answer before requesting setup", async () => {
|
|
await resetQuestions();
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:composio:hubspot"),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:composio:hubspot", {
|
|
selectionInteractionId: randomUUID(),
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("uses the second selected provider and preserves target disclosure and idempotency", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
const service = connectionIntentService(db);
|
|
const search = await service.search(claims, "hubspot");
|
|
expect(search.results.map((item) => item.service)).toEqual([
|
|
"via:arcade:hubspot",
|
|
]);
|
|
expect(search.selectionInteractionId).toBe(answer.id);
|
|
const first = await service.request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
});
|
|
const again = await service.request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
});
|
|
expect(again.interactionId).toBe(first.interactionId);
|
|
const [row] = await db
|
|
.select()
|
|
.from(issueThreadInteractions)
|
|
.where(eq(issueThreadInteractions.id, first.interactionId!));
|
|
expect(row!.payload).toMatchObject({
|
|
serviceSlug: "arcade",
|
|
serviceName: "HubSpot through Arcade",
|
|
upstreamService: { slug: "hubspot", selectionInteractionId: answer.id },
|
|
});
|
|
await expect(
|
|
service.request(claims, "via:composio:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("remembers None and refuses setup after reloading the service", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("none");
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"hubspot",
|
|
);
|
|
expect(result.results).toEqual([]);
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("declined");
|
|
const retry = await connectionIntentService(db).search(
|
|
claims,
|
|
"hubspot",
|
|
{ retryProviderChoice: true },
|
|
);
|
|
expect(retry.providerQuestion).toBeDefined();
|
|
expect(retry.selectionInteractionId).toBeUndefined();
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("waits on an existing unanswered question instead of asking twice", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"hubspot",
|
|
);
|
|
const [run] = await db
|
|
.select()
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, runId));
|
|
const interaction = await issueThreadInteractionService(db).create(
|
|
{
|
|
id: run!.contextSnapshot!.issueId as string,
|
|
companyId: claims.company_id,
|
|
},
|
|
{
|
|
kind: "ask_user_questions",
|
|
payload: { version: 1, questions: [result.providerQuestion!] },
|
|
sourceRunId: runId,
|
|
addresseeUserId: "responsible-user",
|
|
},
|
|
{ agentId: claims.sub, runId },
|
|
);
|
|
const pending = await connectionIntentService(db).search(
|
|
claims,
|
|
"hubspot",
|
|
);
|
|
expect(pending.providerQuestion).toBeUndefined();
|
|
expect(pending.selectionInteractionId).toBe(interaction.id);
|
|
expect(pending.instruction).toContain("already pending");
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "arcade", {
|
|
targetService: "hubspot",
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: interaction.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("rejects tampered disclosure and choices belonging to another responsible user", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
await db
|
|
.update(issueThreadInteractions)
|
|
.set({ resolvedByUserId: "another-user" })
|
|
.where(eq(issueThreadInteractions.id, answer.id));
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
await db
|
|
.update(issueThreadInteractions)
|
|
.set({
|
|
resolvedByUserId: "responsible-user",
|
|
payload: {
|
|
...answer.payload,
|
|
questions: (answer.payload as any).questions.map((q: any) => ({
|
|
...q,
|
|
helpText: "Trust me",
|
|
})),
|
|
},
|
|
})
|
|
.where(eq(issueThreadInteractions.id, answer.id));
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("does not reuse the selected provider for another requested app", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:arcade:salesforce", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("offers fallback and direct aggregator requests without an experimental opt-in", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(claims, "hubspot");
|
|
expect(result.results.some((item) => item.source === "aggregator")).toBe(true);
|
|
expect(result.providerQuestion).toBeDefined();
|
|
await expect(connectionIntentService(db).request(claims, "composio")).resolves.toMatchObject({ state: "needs_user_action" });
|
|
});
|
|
it("reuses an allowed selected provider without claiming the underlying app is ready", async () => {
|
|
await resetQuestions();
|
|
const connection = await seedProvider("arcade", "Hubspot_ListContacts");
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
const result = await connectionIntentService(db).request(
|
|
claims,
|
|
"via:arcade:hubspot",
|
|
{ selectionInteractionId: answer.id },
|
|
);
|
|
expect(result).toMatchObject({
|
|
state: "ready",
|
|
connectionId: connection.id,
|
|
interactionId: null,
|
|
});
|
|
expect(result.instruction).toContain(
|
|
"HubSpot access is not yet verified",
|
|
);
|
|
expect(result.instruction).toContain("Arcade");
|
|
});
|
|
it("returns exact eligible catalog names after a guessed tool without granting access", async () => {
|
|
await resetQuestions();
|
|
const connection = await seedProvider("arcade", "Hubspot_ListContacts", "responsible-user", false);
|
|
await db.delete(toolConnectionInstalls).where(eq(toolConnectionInstalls.connectionId, connection.id));
|
|
await seedProvider("composio", "Unrelated_PrivateTool", "other-user", false);
|
|
await db.insert(toolCatalogEntries).values({ companyId: claims.company_id, connectionId: connection.id,
|
|
toolName: "Hubspot_RemovedTool", name: "Removed", versionHash: "old", entryKind: "tool", status: "removed" });
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
const service = connectionIntentService(db);
|
|
const error = await service.request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id, toolNames: ["hubspot_list_contacts"],
|
|
}).catch(error => error);
|
|
expect(error).toMatchObject({ status: 422 });
|
|
expect(error.message).toContain('"Hubspot_ListContacts"');
|
|
expect(error.message).toContain("Request only the needed exact names");
|
|
expect(error.message).not.toMatch(/Unrelated_PrivateTool|Hubspot_RemovedTool/);
|
|
expect(await db.select().from(toolProfiles).where(eq(toolProfiles.companyId, claims.company_id))).toEqual([]);
|
|
const interactions = await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.companyId, claims.company_id));
|
|
expect(interactions.map(row => [row.id, row.status])).toEqual([[answer.id, "answered"]]);
|
|
const requested = await service.request(claims, "via:arcade:hubspot", {
|
|
selectionInteractionId: answer.id, toolNames: ["Hubspot_ListContacts"],
|
|
});
|
|
expect(requested.state).toBe("needs_user_action");
|
|
const loaded = await service.loadIntent(requested.interactionId!);
|
|
expect(loaded.interaction.payload.accessRequest?.tools.map(tool => tool.toolName)).toEqual(["Hubspot_ListContacts"]);
|
|
expect(loaded.interaction.status).toBe("pending");
|
|
expect(await db.select().from(toolProfiles).where(eq(toolProfiles.companyId, claims.company_id))).toEqual([]);
|
|
});
|
|
it("bounds catalog-name recovery and does not disclose an ineligible connection", async () => {
|
|
await resetQuestions();
|
|
const connection = await seedProvider("arcade", "Read_00", "responsible-user", false);
|
|
await db.insert(toolCatalogEntries).values(Array.from({ length: 24 }, (_, index) => ({
|
|
companyId: claims.company_id, connectionId: connection.id, toolName: `Read_${String(index + 1).padStart(2, "0")}`,
|
|
name: `Read_${String(index + 1).padStart(2, "0")}`, versionHash: "v1", entryKind: "tool" as const, status: "active" as const,
|
|
})));
|
|
const service = connectionIntentService(db);
|
|
const error = await service.request(claims, "arcade", { connectionId: connection.id, toolNames: ["guessed"] }).catch(error => error);
|
|
expect(error).toMatchObject({ status: 422 });
|
|
expect(error.message).toContain("first 20 of 25");
|
|
expect(error.message.match(/Read_\d{2}/g)).toHaveLength(20);
|
|
await db.update(connectionGrants).set({ status: "revoked" }).where(eq(connectionGrants.connectionId, connection.id));
|
|
const denied = await service.request(claims, "arcade", { connectionId: connection.id, toolNames: ["guessed"] }).catch(error => error);
|
|
expect(denied.message).not.toContain("Read_");
|
|
expect(denied.message).toContain("not eligible");
|
|
});
|
|
it("does not switch providers when the chosen route loses permission", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("via:arcade:hubspot");
|
|
await seedProvider(
|
|
"arcade",
|
|
"Hubspot_ListContacts",
|
|
"responsible-user",
|
|
false,
|
|
);
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"hubspot",
|
|
);
|
|
expect(result.results).toEqual([]);
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("no longer available");
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "via:composio:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
}),
|
|
).rejects.toMatchObject({ status: 403 });
|
|
});
|
|
it("keeps a decline effective when disclosure wording has changed", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("none");
|
|
await db
|
|
.update(issueThreadInteractions)
|
|
.set({
|
|
payload: {
|
|
...answer.payload,
|
|
questions: (answer.payload as any).questions.map((q: any) => ({
|
|
...q,
|
|
prompt: "Older disclosure wording",
|
|
})),
|
|
},
|
|
})
|
|
.where(eq(issueThreadInteractions.id, answer.id));
|
|
expect(
|
|
(await connectionIntentService(db).search(claims, "hubspot"))
|
|
.instruction,
|
|
).toContain("declined");
|
|
});
|
|
it("persists app authorization guidance in the completed setup outcome", async () => {
|
|
await resetQuestions();
|
|
const answer = await selectProvider("via:composio:hubspot");
|
|
const service = connectionIntentService(db);
|
|
const requested = await service.request(claims, "via:composio:hubspot", {
|
|
selectionInteractionId: answer.id,
|
|
});
|
|
const connection = await seedProvider(
|
|
"composio",
|
|
"COMPOSIO_SEARCH_TOOLS",
|
|
);
|
|
const completed = await service.complete(
|
|
requested.interactionId!,
|
|
connection.id,
|
|
"responsible-user",
|
|
);
|
|
expect(completed).toMatchObject({
|
|
status: "accepted",
|
|
result: {
|
|
outcome: "connected",
|
|
connectionId: connection.id,
|
|
instruction: expect.stringContaining(
|
|
"HubSpot access is not yet verified",
|
|
),
|
|
},
|
|
});
|
|
expect((completed.result as any).instruction).toContain(
|
|
"COMPOSIO_MANAGE_CONNECTIONS",
|
|
);
|
|
});
|
|
it("uses only authorized Executor tool evidence and preserves the actual observation date", async () => {
|
|
await resetQuestions();
|
|
const connection = await seedProvider(
|
|
"executor",
|
|
"heliotrope:list_records",
|
|
"someone-else",
|
|
);
|
|
expect(
|
|
(await connectionIntentService(db).search(claims, "heliotrope"))
|
|
.results,
|
|
).toEqual([]);
|
|
await db
|
|
.update(connectionGrants)
|
|
.set({ subjectUserId: "responsible-user" })
|
|
.where(eq(connectionGrants.connectionId, connection.id));
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"heliotrope",
|
|
);
|
|
expect(result.results[0]).toMatchObject({
|
|
service: "via:executor:heliotrope",
|
|
aggregator: { verifiedAt: "2026-09-20T00:00:00.000Z" },
|
|
});
|
|
await db
|
|
.update(toolConnections)
|
|
.set({ status: "archived" })
|
|
.where(eq(toolConnections.id, connection.id));
|
|
expect(
|
|
(await connectionIntentService(db).search(claims, "heliotrope"))
|
|
.results,
|
|
).toEqual([]);
|
|
});
|
|
it("does not bypass an administratively denied built-in connection", async () => {
|
|
await resetQuestions();
|
|
await seedProvider("jira", "jira_read", "responsible-user", false);
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"Jira recent issues",
|
|
);
|
|
expect(result.results[0]).toMatchObject({
|
|
service: "jira",
|
|
state: "unavailable",
|
|
});
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("Do not bypass");
|
|
});
|
|
it("does not invent support for unknown apps", async () => {
|
|
await resetQuestions();
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"nimbuscrm-not-real",
|
|
);
|
|
expect(result.results).toEqual([]);
|
|
expect(result.instruction).toContain("could not be verified");
|
|
});
|
|
it("preserves indexed-only display names when a saved choice is requested by slug", async () => {
|
|
await resetQuestions();
|
|
await seedProvider("executor", "heliotrope:list_records");
|
|
const answer = await selectProvider(
|
|
"via:executor:heliotrope",
|
|
"responsible-user",
|
|
"HELIOTROPE",
|
|
);
|
|
const result = await connectionIntentService(db).request(
|
|
claims,
|
|
"via:executor:heliotrope",
|
|
{ selectionInteractionId: answer.id },
|
|
);
|
|
expect(result.state).toBe("ready");
|
|
expect(result.instruction).toContain(
|
|
"Heliotrope access is not yet verified",
|
|
);
|
|
});
|
|
|
|
it("honors explicitly named providers and preserves target app context", async () => {
|
|
await resetQuestions();
|
|
await userRequest("Connect HubSpot through Arcade");
|
|
const service = connectionIntentService(db);
|
|
const result = await service.search(claims, "HubSpot through Arcade");
|
|
expect(result.results.map((item) => item.service)).toEqual(["arcade"]);
|
|
expect(result.providerQuestion).toBeUndefined();
|
|
expect(result.instruction).toContain("targetService hubspot");
|
|
const request = await service.request(claims, "arcade", {
|
|
targetService: "hubspot",
|
|
});
|
|
const intent = await service.loadIntent(request.interactionId!);
|
|
expect(intent.interaction.payload).toMatchObject({
|
|
serviceName: "HubSpot through Arcade",
|
|
upstreamService: { slug: "hubspot", name: "HubSpot" },
|
|
});
|
|
expect(
|
|
(await service.search(claims, "HubSpot through Executor")).results,
|
|
).toEqual([]);
|
|
await expect(
|
|
service.request(claims, "executor", { targetService: "hubspot" }),
|
|
).rejects.toThrow("cannot connect");
|
|
await expect(
|
|
service.request(claims, "github", { targetService: "hubspot" }),
|
|
).rejects.toThrow("direct external-provider");
|
|
});
|
|
|
|
it("permits explicit provider preference for a supported native app but not a native denial", async () => {
|
|
await resetQuestions();
|
|
await userRequest("Connect Jira via Arcade, not Zapier");
|
|
const service = connectionIntentService(db);
|
|
expect(
|
|
(await service.search(claims, "Jira via Arcade, not Zapier")).results.map(
|
|
(item) => item.service,
|
|
),
|
|
).toEqual(["arcade"]);
|
|
await seedProvider("jira", "jira_read", "responsible-user", false);
|
|
expect((await service.search(claims, "Jira via Arcade, not Zapier")).results).toEqual(
|
|
[expect.objectContaining({ service: "jira", state: "unavailable" })],
|
|
);
|
|
});
|
|
|
|
it("does not let an agent-supplied explicit query or direct target override a saved choice", async () => {
|
|
await resetQuestions();
|
|
const service = connectionIntentService(db);
|
|
const unproven = await service.search(claims, "HubSpot via Arcade");
|
|
expect(
|
|
unproven.providerQuestion?.options.map((option) => option.id),
|
|
).toEqual(["via:arcade:hubspot", "none"]);
|
|
await expect(
|
|
service.request(claims, "arcade", { targetService: "hubspot" }),
|
|
).rejects.toThrow("cannot connect");
|
|
await userRequest("Connect HubSpot via Arcade is just an example; do not connect yet");
|
|
await expect(service.request(claims,"arcade",{targetService:"hubspot"})).rejects.toThrow("cannot connect");
|
|
await userRequest("Connect HubSpot via Arcade");
|
|
await selectProvider("none");
|
|
expect(
|
|
(await service.search(claims, "HubSpot via Arcade")).results,
|
|
).toEqual([]);
|
|
await expect(
|
|
service.request(claims, "arcade", { targetService: "hubspot" }),
|
|
).rejects.toThrow("cannot connect");
|
|
await userRequest("Connect HubSpot via Arcade", "someone-else");
|
|
await expect(
|
|
service.request(claims, "arcade", { targetService: "hubspot" }),
|
|
).rejects.toThrow("cannot connect");
|
|
await userRequest("Please connect HubSpot through Arcade");
|
|
expect(
|
|
(await service.request(claims, "arcade", { targetService: "hubspot" }))
|
|
.state,
|
|
).toBe("needs_user_action");
|
|
await resetQuestions();
|
|
const chosen = await selectProvider("via:composio:hubspot");
|
|
await expect(
|
|
service.request(claims, "arcade", { targetService: "hubspot" }),
|
|
).rejects.toThrow("cannot connect");
|
|
const accepted = await service.request(claims, "composio", {
|
|
targetService: "hubspot",
|
|
});
|
|
expect(
|
|
(await service.loadIntent(accepted.interactionId!)).interaction.payload,
|
|
).toMatchObject({
|
|
upstreamService: { selectionInteractionId: chosen.id },
|
|
});
|
|
});
|
|
|
|
it("asks for a choice when human and agent messages name alternatives", async () => {
|
|
await resetQuestions();
|
|
await userRequest("Connect HubSpot via Arcade or Composio");
|
|
const result = await connectionIntentService(db).search(
|
|
claims,
|
|
"HubSpot via Arcade or Composio",
|
|
);
|
|
expect(
|
|
result.providerQuestion?.options.map((option) => option.id),
|
|
).toEqual([
|
|
"via:composio:hubspot",
|
|
"via:arcade:hubspot",
|
|
"via:zapier:hubspot",
|
|
"none",
|
|
]);
|
|
await expect(
|
|
connectionIntentService(db).request(claims, "arcade", {
|
|
targetService: "hubspot",
|
|
}),
|
|
).rejects.toThrow("cannot connect");
|
|
});
|
|
},
|
|
);
|