Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): resume channel progress after auth (#1023)

Allen Zhoua70d4ce56576
diff --git a/.changeset/warm-spoons-resume.md b/.changeset/warm-spoons-resume.md
new file mode 100644
index 000000000..91dd23062
--- /dev/null
+++ b/.changeset/warm-spoons-resume.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Restart native progress feedback across built-in chat channels when a completed connection authorization resumes the agent session. Slack also shows an explicit connected and resuming status.
diff --git a/packages/eve/src/public/channels/discord/defaults.ts b/packages/eve/src/public/channels/discord/defaults.ts
index 030c6203f..4d972d297 100644
--- a/packages/eve/src/public/channels/discord/defaults.ts
+++ b/packages/eve/src/public/channels/discord/defaults.ts
@@ -55,6 +55,12 @@ export const defaultEvents: DiscordChannelEvents = {
await channel.discord.startTyping();
},
+ async "authorization.completed"(event, channel, _ctx) {
+ if (event.outcome === "authorized") {
+ await channel.discord.startTyping();
+ }
+ },
+
async "actions.requested"(_event, channel, _ctx) {
await channel.discord.startTyping();
},
diff --git a/packages/eve/src/public/channels/discord/discordChannel.test.ts b/packages/eve/src/public/channels/discord/discordChannel.test.ts
index fb88340a7..2ac1c4cef 100644
--- a/packages/eve/src/public/channels/discord/discordChannel.test.ts
+++ b/packages/eve/src/public/channels/discord/discordChannel.test.ts
@@ -367,7 +367,7 @@ describe("discordChannel() inbound route", () => {
});
describe("discordChannel() default event handlers", () => {
- it("posts best-effort typing indicators for turn and action progress", async () => {
+ it("posts best-effort typing indicators for turn, authorization, and action progress", async () => {
const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
vi.stubGlobal("fetch", fetchMock);
const adapter = withState(
@@ -380,6 +380,17 @@ describe("discordChannel() default event handlers", () => {
const ctx = buildAdapterContext(adapter, accessor);
await callEvent(adapter, makeEvent("turn.started", {}), ctx);
+ await callEvent(
+ adapter,
+ makeEvent("authorization.completed", {
+ name: "notion",
+ outcome: "authorized",
+ sequence: 0,
+ stepIndex: 0,
+ turnId: "t1",
+ }),
+ ctx,
+ );
await callEvent(
adapter,
makeEvent("actions.requested", {
@@ -390,7 +401,7 @@ describe("discordChannel() default event handlers", () => {
ctx,
);
- expect(fetchMock).toHaveBeenCalledTimes(2);
+ expect(fetchMock).toHaveBeenCalledTimes(3);
for (const [url, init] of fetchMock.mock.calls) {
expect(String(url)).toBe("https://discord.com/api/v10/channels/C01/typing");
expect(new Headers((init as RequestInit).headers).get("authorization")).toBe("Bot bot-token");
diff --git a/packages/eve/src/public/channels/slack/defaults.test.ts b/packages/eve/src/public/channels/slack/defaults.test.ts
index 80a8afb3b..804814b09 100644
--- a/packages/eve/src/public/channels/slack/defaults.test.ts
+++ b/packages/eve/src/public/channels/slack/defaults.test.ts
@@ -23,9 +23,10 @@ const sessionCtx = sessionContext();
function buildChannelStub(state: Partial<SlackChannelState> = {}) {
const postEphemeral = vi.fn().mockResolvedValue({ id: "eph1" });
const post = vi.fn().mockResolvedValue({ id: "ts1" });
+ const startTyping = vi.fn().mockResolvedValue(undefined);
const request = vi.fn().mockResolvedValue({ ok: true });
const channel = {
- thread: { postEphemeral, post } as Partial<SlackEventContext["thread"]>,
+ thread: { postEphemeral, post, startTyping } as Partial<SlackEventContext["thread"]>,
slack: { channelId: "C123", request } as Partial<SlackEventContext["slack"]>,
state: {
channelId: "C123",
@@ -34,7 +35,7 @@ function buildChannelStub(state: Partial<SlackChannelState> = {}) {
...state,
},
} as SlackEventContext;
- return { channel, post, postEphemeral, request };
+ return { channel, post, postEphemeral, request, startTyping };
}
function authRequiredEvent(
@@ -150,6 +151,25 @@ describe("defaultEvents authorization.required", () => {
});
describe("defaultEvents authorization.completed", () => {
+ it("shows that the session is resuming after authorization succeeds", async () => {
+ const { channel, startTyping } = buildChannelStub({ triggeringUserId: "U777" });
+
+ await defaultEvents["authorization.completed"]!(
+ {
+ authorization: { displayName: "Notion Workspace" },
+ name: "notion",
+ outcome: "authorized",
+ sequence: 1,
+ stepIndex: 0,
+ turnId: "turn_0",
+ },
+ channel,
+ sessionCtx,
+ );
+
+ expect(startTyping).toHaveBeenCalledWith("Connected to Notion Workspace. Resuming...");
+ });
+
it("edits the public status in place when one was posted", async () => {
const { channel, postEphemeral, request } = buildChannelStub({
triggeringUserId: "U777",
diff --git a/packages/eve/src/public/channels/slack/defaults.ts b/packages/eve/src/public/channels/slack/defaults.ts
index a6d01506e..48008eaa2 100644
--- a/packages/eve/src/public/channels/slack/defaults.ts
+++ b/packages/eve/src/public/channels/slack/defaults.ts
@@ -288,11 +288,15 @@ export const defaultEvents: SlackChannelInternalEvents = {
},
async "authorization.completed"(event, channel, _ctx) {
+ const displayName = event.authorization?.displayName ?? formatConnectionDisplayName(event.name);
+ if (event.outcome === "authorized") {
+ await channel.thread.startTyping(`Connected to ${displayName}. Resuming...`);
+ }
+
const pending = channel.state.pendingAuthMessageTs ?? {};
const ts = pending[event.name];
if (ts === undefined) return;
- const displayName = event.authorization?.displayName ?? formatConnectionDisplayName(event.name);
const text = buildAuthCompletedText({
displayName,
outcome: event.outcome as ConnectionAuthorizationOutcome,
diff --git a/packages/eve/src/public/channels/teams/defaults.test.ts b/packages/eve/src/public/channels/teams/defaults.test.ts
index d966dd4ad..0770855b8 100644
--- a/packages/eve/src/public/channels/teams/defaults.test.ts
+++ b/packages/eve/src/public/channels/teams/defaults.test.ts
@@ -8,10 +8,11 @@ const sessionCtx = {} as SessionContext;
function buildChannelStub(state: Partial<TeamsChannelState> = {}) {
const post = vi.fn().mockResolvedValue({ id: "act1" });
+ const startTyping = vi.fn().mockResolvedValue(undefined);
const update = vi.fn().mockResolvedValue(undefined);
const channel = {
adaptiveCardVersion: "1.5",
- thread: { post, update } as Partial<TeamsEventContext["thread"]>,
+ thread: { post, startTyping, update } as Partial<TeamsEventContext["thread"]>,
state: {
bot: null,
channelId: null,
@@ -25,7 +26,7 @@ function buildChannelStub(state: Partial<TeamsChannelState> = {}) {
...state,
},
} as TeamsEventContext;
- return { channel, post, update };
+ return { channel, post, startTyping, update };
}
function authRequiredEvent(overrides: { displayName?: string } = {}) {
@@ -70,6 +71,18 @@ describe("defaultEvents authorization.required", () => {
});
describe("defaultEvents authorization.completed", () => {
+ it("restarts the typing indicator after authorization succeeds", async () => {
+ const { channel, startTyping } = buildChannelStub();
+
+ await defaultEvents["authorization.completed"]!(
+ { name: "notion", outcome: "authorized", sequence: 1, stepIndex: 0, turnId: "turn_0" },
+ channel,
+ sessionCtx,
+ );
+
+ expect(startTyping).toHaveBeenCalledTimes(1);
+ });
+
it("renders the challenge displayName in the completion status", async () => {
const { channel, update } = buildChannelStub({ pendingAuthActivityId: "act1" });
diff --git a/packages/eve/src/public/channels/teams/defaults.ts b/packages/eve/src/public/channels/teams/defaults.ts
index 32c2a6e15..a217f8a88 100644
--- a/packages/eve/src/public/channels/teams/defaults.ts
+++ b/packages/eve/src/public/channels/teams/defaults.ts
@@ -159,6 +159,10 @@ export const defaultEvents: TeamsChannelEvents = {
},
async "authorization.completed"(event, channel, _ctx) {
+ if (event.outcome === "authorized") {
+ await channel.thread.startTyping();
+ }
+
const activityId = channel.state.pendingAuthActivityId;
if (!activityId) return;
const displayName = event.authorization?.displayName ?? formatConnectionDisplayName(event.name);
diff --git a/packages/eve/src/public/channels/telegram/defaults.ts b/packages/eve/src/public/channels/telegram/defaults.ts
index a18662389..6333ea670 100644
--- a/packages/eve/src/public/channels/telegram/defaults.ts
+++ b/packages/eve/src/public/channels/telegram/defaults.ts
@@ -59,6 +59,12 @@ export const defaultEvents: TelegramChannelEvents = {
await channel.telegram.startTyping();
},
+ async "authorization.completed"(event, channel, _ctx) {
+ if (event.outcome === "authorized") {
+ await channel.telegram.startTyping();
+ }
+ },
+
async "actions.requested"(_event, channel, _ctx) {
await channel.telegram.startTyping();
},
diff --git a/packages/eve/src/public/channels/telegram/telegramChannel.test.ts b/packages/eve/src/public/channels/telegram/telegramChannel.test.ts
index e39e986cb..bb9b9ddb7 100644
--- a/packages/eve/src/public/channels/telegram/telegramChannel.test.ts
+++ b/packages/eve/src/public/channels/telegram/telegramChannel.test.ts
@@ -333,6 +333,35 @@ describe("telegramChannel() deliver hook", () => {
});
describe("telegramChannel() default event handlers", () => {
+ it("restarts the typing indicator after authorization succeeds", async () => {
+ const fetchMock = vi.fn().mockResolvedValue(
+ new Response(JSON.stringify({ ok: true, result: true }), {
+ headers: { "content-type": "application/json" },
+ }),
+ );
+ vi.stubGlobal("fetch", fetchMock);
+ const adapter = withState(
+ getAdapter(telegramChannel({ credentials: { botToken: "bot-token" } })),
+ { chatId: "42", chatType: "private" },
+ );
+ const ctx = buildAdapterContext(adapter, { get: () => undefined, set: () => {} } as any);
+
+ await callEvent(
+ adapter,
+ makeEvent("authorization.completed", {
+ name: "notion",
+ outcome: "authorized",
+ sequence: 0,
+ stepIndex: 0,
+ turnId: "t1",
+ }),
+ ctx,
+ );
+
+ const body = JSON.parse(String((fetchMock.mock.calls[0]![1] as RequestInit).body));
+ expect(body).toEqual({ action: "typing", chat_id: "42" });
+ });
+
it("input.requested posts an inline keyboard and stores compact callback mappings", async () => {
const fetchMock = vi
.fn()