Point all @copilotkit/* deps at workspace:* so the example uses local source (the Telegram work is unpublished and depends on the core HITL fix). Add global unhandledRejection/uncaughtException handlers and guard the onMention/onThreadStarted handlers so a failed turn cannot crash the bot. Update deploy docs.
Unify WhatsApp with main's Slack+Discord multi-adapter demo: WhatsApp becomes a
third env-gated platform block in examples/slack/app/index.ts (listening on
Railway $PORT, with a malformed-PORT guard). Keep the platform-aware
senderContext (also fixes the Discord 'Slack user' label); drop the superseded
buildAdapters helper for main's inline per-platform pattern. package.json takes
main's ~0.0.2 bumps + bot-discord and adds bot-whatsapp (workspace:~); README
intro + deploy section cover all three surfaces.
- Implemented audio transcription capabilities with error handling.
- Refactored CopilotChat component to utilize a directive for handling attachments.
- Improved CopilotChatReasoningMessage to manage streaming state and elapsed time more efficiently.
- Added new scroll view component for better message display and auto-scrolling behavior.
- Updated styles for A2UI surface components to enhance layout and scrolling.
- Enhanced tests for OpenGenerativeUIRenderer to ensure proper height measurement.
examples/slack now starts a Slack bot and/or a Telegram bot from one platform-neutral app layer, env-conditional on which credentials are set. Neutralized Slack-specific rendering so the shared components work on both platforms: unicode glyphs instead of mrkdwn shortcodes, no Block Kit raw fallbacks, neutral context/tool wording. Migrated the Telegram e2e smoke harness and BotFather setup docs; removed the separate examples/telegram app.
Add display-only generative-UI the copilot renders on request:
- showPendingApprovals — the dashboard's interactive approval table, in chat
- showSpendingTrend, showBudgetUsage, showSpendBreakdown, showIncomeVsExpenses —
brand-styled charts (dependency-free, hand-rolled SVG/CSS)
- showApprovalFlow — a diagram of how an over-limit charge gets cleared
Registered globally in copilot-context (so they work on any route) and routed
via the agent prompt.
- Cards page: the credit-card grid compressed each card (wrapping the holder /
valid-thru text) when the chat panel narrowed the content area. It's now a
horizontal-scroll row — each card holds a 300px minimum and grows to fill on
wide screens, scrolling instead of squishing.
- overflow-x:auto forces overflow-y:auto, which clipped the cards' soft drop
shadows; matching negative-margin/padding pairs give the shadows room inside
the scroll viewport without moving the cards.
- Chat: space stacked HITL/action cards so consecutive cards no longer share an
edge (CopilotKit stacks them with no row-gap).
- webhook: don't let GET / health shadow the verify handshake when WHATSAPP_PATH=/
- adapters: fail loud on a malformed PORT instead of binding NaN
- tests: cover the id-only senderContext branch, the 404-regression for the
health route, and the PORT guard
- docs: update README senderContext snippets to the 2-arg signature
Adds a cookbook recipe + runnable showcase that gives the Built-in Agent
OAuth-backed Arcade tools (Gmail, Google News) and renders Arcade's one-time
authorization step as a generative-UI "Connect" card in the chat.
- docs: showcase/shell-docs/src/content/docs/cookbook/arcade.mdx (+ meta.json, index card)
- app: examples/showcases/arcade-tools (Next.js App Router, single-route runtime)
Co-authored-by: Cursor <cursoragent@cursor.com>
- add render_chart tool: builds a QuickChart image, fetches the PNG server-side
and uploads the bytes to WhatsApp (no headless browser, no fragile external
fetch by WhatsApp); update the agent prompt to use it
- onMessage: fail loud — post a visible error to the user if a turn throws,
instead of leaving them with silence
- issue_list: use **bold** so issue ids render bold on WhatsApp
## Summary
- Update the default tool-call renderer to use dark-theme-aware classes
for the card, header, status badge, and detail panels
- Add coverage for the dark theme styling path in unit tests
- Add a Storybook example that demonstrates the default tool renderer on
a dark CopilotKit surface
## Testing
- Added unit tests for the renderer’s dark-theme class output and
expanded details state
- Not run (not requested)
Keeps package-lock.json in sync with the core bump pulled in from main
(#5489) so the agent lockfile is not stale after the rebase.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
The previous lockfiles were written with `npm install --package-lock-only`,
which left out optional transitive deps (e.g. @emnapi/wasi-threads). The
Docker smoke-starter build runs strict `npm ci`, which then failed with
"package.json and package-lock.json not in sync" (crewai-crews, 9s fail).
Regenerated each lockfile with a full `npm install --ignore-scripts` so the
tree is complete. Verified `npm ci` now succeeds (crewai-crews, mastra) and
all resolve @ag-ui/client 0.0.57.
Follow-up to the @copilotkit 1.60.1 bump so the integration-demo parity
check passes. The north-star (langgraph-python) is now on 1.60.1, and the
_parity manifest requires every examples/integrations/* demo to track the
same @copilotkit version — so all integrations must move together.
- @copilotkit/* 1.60.0 -> 1.60.1 across the remaining integrations.
- Starter-fleet apps force a single @ag-ui tree via `overrides`
(@ag-ui/client|core|encoder|proto). Bump that single-tree pin
0.0.53/0.0.55 -> 0.0.57 so they actually carry the HttpAgent fetch fix
(Illegal invocation) instead of a 1.60.1<->0.0.55 skew. Adapter packages
(@ag-ui/crewai, @ag-ui/mastra, @ag-ui/llamaindex, @ag-ui/a2a, middlewares)
are left untouched.
- Lockfiles regenerated; all resolve @ag-ui/client 0.0.57.
Per-integration smoke-starter CI validates each starter against 0.0.57.
The chat never responds and the browser console shows
"TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation"
on every agent run (onRunFailed, agentId: default).
Root cause is in @ag-ui/client@0.0.56's HttpAgent: it stores the global
fetch unbound (`this.fetch = config.fetch ?? fetch`) and later invokes it
as `this.fetch(...)`, so native fetch runs with the agent instance as its
receiver instead of `window`. Native fetch is brand-checked and throws
"Illegal invocation". It surfaces in both dev and prod.
Fixed upstream in @ag-ui/client@0.0.57 (`config.fetch ?? ((url, init) =>
fetch(url, init))`), which shipped in @copilotkit/* 1.60.1. Bumping these
examples 1.60.0 -> 1.60.1 pulls 0.0.57 transitively; lockfiles regenerated.
Scope: only the examples that take @ag-ui transitively from react-core are
bumped here. Other integration examples force-pin @ag-ui via `overrides`
to 0.0.53/0.0.55, where 1.60.1 would create a version skew; those need a
per-integration bump and are intentionally left out of this change.
The langgraph-js smoke-starter job crashes on agent startup with
"'@langchain/core/utils/uuid' does not provide an export named 'v6'".
@langchain/langgraph@1.3.0 depends on @langchain/langgraph-checkpoint@^1.0.2.
Checkpoint 1.1.1 (published 2026-06-12) imports v6 and raised its peer to
@langchain/core@^1.1.48. The agent pinned core 1.1.44, which predates the v6
export. The Docker agent build runs `npm install` against package.json (no
lockfile), so it floats to checkpoint 1.1.1 against the too-old core.
Bumping core to 1.1.49 restores the v6 export and satisfies the peer range.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
examples/slack ships a standalone pnpm-lock.yaml (used by Railway when building
with rootDirectory=/examples/slack). PR #5478 fixed the root workspace lockfile
but not this one, so it still pinned @copilotkit/bot* at ~0.0.1 while
package.json now requires ~0.0.2 — pnpm install --frozen-lockfile failed with
ERR_PNPM_OUTDATED_LOCKFILE on deploy.
Regenerate it with the repo's pinned pnpm (10.33.4) via
pnpm -C examples/slack install --ignore-workspace --lockfile-only: importer
specifiers are now ~0.0.2 resolving to the published 0.0.2, the @ai-sdk/mcp
override is preserved. Verified: CI=true frozen install reports "Lockfile is
up to date" (exit 0).
Document that the slack example consumes the published @copilotkit/bot*
packages and that deploys (e.g. Railway) must include the repo-root
pnpm-lock.yaml / package.json in their watch paths, so a dependency bump
triggers a rebuild and a frozen install doesn't fail on an out-of-date
lockfile. Touches examples/slack/** to trigger the Railway redeploy of the
current main (which now carries the deployable-lockfile fix).
@copilotkit/bot, @copilotkit/bot-slack, and @copilotkit/bot-ui are published at
0.0.2 (agent-native assistant pane + native streaming). Point the slack
example's dependency ranges at ~0.0.2 so a deployed/standalone install pulls
the new packages. Local monorepo installs already use the workspace copies via
root pnpm.overrides, so the lockfile is unchanged.
useCreditCards() kept per-instance React state and was called independently by
the dashboard page and by copilot-context (where the chat's approve / finalize /
open-exception tools live). A mutation made through one instance refetched only
itself — so when the agent approved an over-limit charge in chat, the dashboard
pending table kept showing it as pending until a manual reload.
Add a module-level revalidation bus: each useCreditCards() instance registers a
refetch callback, and every mutation calls notifyDataChanged() to fan a refetch
out to all live instances. The dashboard now reflects agent-driven approvals
immediately (verified: recall-approve in chat drops the charge from the pending
table with no reload).
Adds a "What each mode actually recalls" subsection to the demo README: in OSS
mode the taught workflow is recalled only within the same conversation (the
saved procedure is echoed back into that thread), so a brand-new chat won't know
it — that's expected. Cross-conversation persistence is what the external
Intelligence backend provides. Names the symptom explicitly so reviewers aren't
surprised when a new conversation "doesn't know" the workflow in OSS mode.
Rework the dashboard's Pending approval view and fix two approval-gate UX bugs
on the banking demo (PR #5266):
- Table layout: replace the center-stacked per-row card with a scannable table
(Merchant / Amount / Policy / Actions). Actions are check / x icon buttons plus
a "more actions" overflow menu holding File policy exception. Status is its own
column (Over limit / Cleared / Within limit), and Approve is gated until the
charge is actually clearable.
- Fix the table shrinking when the more-actions menu opens: the Radix menu is
modal by default and engaged react-remove-scroll, whose scrollbar compensation
reflowed the table. Set modal={false} (a row menu needn't be modal) and add
whitespace-nowrap to the status badges.
- Fix "cannot approve after filing an exception": the inline card offered all
codes, including non-justifying ones that set activeExceptionId (flipping the
row to Cleared) but never lift the server gate, so the approve 422'd silently.
The card exists to clear an over-limit charge, so it now offers only justifying
codes. The gate itself is unchanged.
Verified live in OSS dev: file (justifying) -> Cleared -> approve succeeds; the
menu opens without reflow; lint + build green.
The recorder was a floating HUD overlay, which read as a different UI element
from the in-chat cards (e.g. "Save this workflow?"). Fold the live step feed
into the demonstration card itself: the `awaitDashboardDemonstration` card is
now titled "Recording your workflow" (with a REC pulse), keeps the
non-directional copy, and embeds a reactive `<RecordingSteps/>` child that
narrates each captured action inside the card. Removes the floating panel and
its CSS. Same card chrome as the other cards, so it reads consistently in the
conversation.
`RecordingSteps` subscribes to the recording context itself (not via the host
card's render closure), so it updates live as each step is logged without a
stale-closure dep.
Address review feedback on the banking self-learning "teach a workflow" loop
(PR #5266):
- Recorder HUD: a floating "Recording your workflow" panel narrates each officer
action live (Opened Dashboard -> Opened Transactions -> Opened Pending approval
-> Opened the exception form -> Filed the policy exception -> Approved the
charge), driven by logStep on the nav / tab / file-exception / approve call
sites. New recording-feed.tsx; steps + logStep added to recording-context.
- Non-directional demonstration: the await card is retitled "Show me how" and no
longer lists the steps ("go ahead and do it yourself now and I'll watch and
learn"); the agent's spoken handoff is likewise generic.
- Fix the "nothing happens after I'm done" stall: the model sometimes asked
"should I save this?" in prose instead of calling saveLearnedWorkflow, leaving
no Save card to click. The await tool-result is now directive (call
saveLearnedWorkflow; the card is how you ask), reinforced in the prompt.
- Harden the ending: after saving, the agent treats the demonstrated charge as
already cleared and waits, instead of re-running the freshly-saved procedure
on it.
Verified end-to-end in OSS dev (taught Google Ads, recalled AWS); lint + build
green.
The YAML manifest was missing the app_home block the JSON variant has, so
apps created from it showed "Sending messages to this app has been turned
off". Add app_home with the Messages tab enabled (not read-only), matching
slack-app-manifest.json.
Rework the banking demo's teach-a-workflow loop so the officer demonstrates the
over-limit unlock on the actual dashboard instead of an inline chat card, and so
the first over-limit approve request no longer shows an approval card that fails.
When asked to approve an over-limit charge it has no saved procedure for, the
agent now declines and offers to record (no approval card). The officer opens the
new Dashboard -> Transactions -> Pending approval view, files a policy exception
and approves the charge there; a waiting card holds the chat until they click
"I'm done". The agent then saves the procedure and applies it itself to a
different over-limit charge.
Move the teach/recall HITL tools (offerWorkflowRecording,
awaitDashboardDemonstration, saveLearnedWorkflow, openPolicyException,
finalizePolicyException, approveTransaction) and the agent data/permission
readables into the global CopilotContext. A route-scoped registration unmounts
when the officer navigates to the dashboard, which drops the in-progress card and
prevents the followUp from firing; global registration survives navigation and
renders on every route.
The demonstrated exception code is captured via the recording context and handed
to the Save step, so the saved procedure names the exact code used. The agent
prompt is updated for the decline+offer and dashboard handoff, and still never
spells out the unlock or names a justifying code.
Verified end-to-end in OSS dev (lint + build green, gate smoke 3/3): Beat 1 shows
no card, the dashboard demonstration clears the Google Ads charge, and recall
clears the AWS charge via the learned procedure.
Update package READMEs + ARCHITECTURE for the assistant pane, native streaming,
and the new onThreadStarted / setSuggestedPrompts / setTitle surface. Reverse
the slack.mdx callout that told users to delete the assistant scopes (now
required), and enable the pane in the examples/slack manifest (assistant_view +
assistant:write + assistant_thread_* events) with a dev-ex onThreadStarted
greeting and the assistant config.
The self-learning recorder POSTs to the annotate endpoint, which only exists with an
Intelligence backend; in OSS mode it returns 422. Call sites logged that rejection with
console.error, which Next.js 16 surfaces as a full-screen dev error overlay mid-demo even
though the failure is expected and harmless.
Swallow the failure in the recorder seam (useRecordUserActionInCurrentThread): catch it and
log quietly via console.debug instead of letting it reject. Recording stays best-effort — a
no-op without an Intelligence backend, and unchanged (records normally) with one.
Drive the FOR-137 self-learning story as an agent-orchestrated, narrated loop. When an
over-limit approval is rejected, the agent offers to record a workflow; the officer
demonstrates by filing a policy exception; the agent summarizes and saves the procedure;
then it applies that procedure itself to a different over-limit charge. Same-session recall
works by echoing the learned procedure back into the thread.
page.tsx: three new human-in-the-loop tools (offerWorkflowRecording,
recordExceptionDemonstration, saveLearnedWorkflow) plus a transactions agent-readable so the
agent resolves a charge the user names to the right id instead of guessing.
openPolicyException now returns the new exception id, and the agent-driven exception tools
are followUp:true so the recall chain (open then finalize then approve) does not stall.
route.ts: TEACH & RECALL prompt rules and an ACTION DISCIPLINE carve-out. The prompt does
not restate the unlock procedure, preserving the learning invariant.
policy-exception-inline.tsx: surface the demonstrated exception code via onFiled(code).
scripts/over-limit-gate-smoke.mjs: regression guard proving only a finalized
justifying-code exception lifts the policy-limit gate.
Verified end-to-end in OSS dev mode (lint and build green): the demonstration clears the
Google Ads charge and recall clears the AWS charge with a single successful approve.
Rewire the before-first-message suggestion pills to drive the FOR-137
self-learning story: (1) the teachable over-limit ask, (2) surface the pending
charges so the officer can demonstrate the unlock, (3) recall on a different
over-limit charge on a fresh thread. Titles stay symptom-only so they do not
hint at the exception path the agent is meant to learn on its own.
The banking demo's human-in-the-loop tools registered their render in a
mount-keyed effect (useFrontendTool), so without a deps array the render
closure froze on the EMPTY initial cards/policies/transactions. Those arrays
load async after mount, so the registered render kept filtering empty data:
showAndApproveTransactions painted a card with no rows (the agent-driven
approve flow appeared to do nothing), and assignPolicyToCard / setCardPin /
addNoteToTransaction showed raw ids instead of the resolved card/transaction.
Pass the data each render reads as the useHumanInTheLoop deps so it
re-registers when that data loads, mirroring the existing selectCard and
showTransactions (useComponent) deps. addNewCard / openPolicyException /
finalizePolicyException render their args only, so they are left as-is.
Verified against unmodified workspace react-core: the agent-driven approval
card now renders the Google Ads charge with its over-limit badge and the
file-exception action instead of a blank card.
Bumps every @copilotkit/* pin (react-core, react-ui, runtime, a2ui-renderer,
sdk-js) from 1.59.5 to 1.60.0 across the threads-enabled integration examples,
and regenerates each package-lock.json to the 1.60.0 dependency closure.
Excludes the vestigial langgraph-python-threads example.
Updates the shared `_intelligence` activation overlay to the composite 0.5.0
image and removes the `provision-user` one-shot service. That service seeded
`cpki.users` (a bare id plus a per-project `<projectId>_<userId>` alias) so the
runtime's `demo-user` identity satisfied `threads_user_id_fkey`. The 0.5.0
composite provisions thread users on demand, so the manual seed is obsolete.
Alem Tuzlak