copilotkit 4.6.0 → 4.8.0

package/README.md

@@ -77,7 +77,17 @@ persistence, insights), and `init` provisions a free license automatically —
 you sign in with your browser during scaffolding. The `-i`/`--intelligence`
 flag is retained as a deprecated no-op for backward compatibility.
 
-Supported framework values include `langgraph-py`, `langgraph-js`, `claude-sdk-typescript`, `claude-sdk-python`, `mastra`, `pydantic-ai`, `aws-strands-py`, `adk`, `adk-angular`, `a2a`, `microsoft-agent-framework-dotnet`, `microsoft-agent-framework-py`, `flows`, `llamaindex`, `agno`, `ag2`, `mcp-apps`, `agentcore-langgraph`, `agentcore-strands`, `a2ui`, and `opengenui`.
+Rather than maintaining the list of framework values here, ask the CLI:
+
+```bash
+copilotkit framework list
+copilotkit framework list --json
+```
+
+It reports every value `-f` accepts, the language each framework's agent is
+written in, and which init flags that framework supports — `-i`, `--mock`, and
+`--channel` are each accepted only for some. It answers from a catalog compiled into the
+binary, so it needs no API call, no authentication, and no TTY.
 
 `init` and `create` collect your starter choices, then connect project creation
 to your CopilotKit workspace through Ops/Clerk before scaffolding. If you
@@ -104,8 +114,15 @@ copilotkit channels status
 copilotkit channels list
 copilotkit channels rotate support --adapter slack
 copilotkit channels setup
+copilotkit channels providers
 ```
 
+`channels providers` lists the chat providers a Channel can use and the
+credentials each one asks for, named as that provider's own console names them.
+Unlike every other `channels` subcommand it answers from a compiled-in catalog, so
+it needs no selected project, no credentials, and no API call. Note it is distinct
+from `channels list`, which reports the Channels that exist in _your_ project.
+
 This configures **managed Intelligence Channels**. It does not configure the
 open-source `@copilotkit/channels` adapter packages, which are a separate product
 that shares the words "channels" and "Slack".
@@ -123,35 +140,49 @@ terminal the CLI offers a masked prompt instead.
 
 ### Agent-assisted setup
 
-Most of Slack setup is browser work — creating the app, collecting its tokens,
-installing it into a workspace. `channels setup` hands that to your coding
-agent instead of walking it yourself:
+Much of Slack and Teams setup happens in a provider website — creating the app,
+collecting its tokens, installing it into a workspace. `channels setup` hands
+that work to your coding agent instead of you walking it yourself:
 
 ```bash
 copilotkit channels setup
 copilotkit channels setup --no-clipboard
 ```
 
-It prints a setup prompt and copies it to your clipboard; paste it into Claude
-(or your coding agent) to start. The prompt is always printed, so you can read
-it before handing it over. Pass `--no-clipboard` in a headless or remote shell.
+It installs the `channels-setup` skill, then prints a one-line prompt to paste
+into your coding agent and copies it to your clipboard. The prompt is always
+printed, so you can read it before handing it over. Pass `--no-clipboard` in a
+headless or remote shell.
 
-The prompt points at the `setup-slack-channel` skill, so install the skills
-first:
+Everything the run needs is in the skill, so the prompt only names the skill and
+the goal. It does not name a provider: Slack or Microsoft Teams is the skill's
+own first question.
+
+Only the prompt goes to stdout. The line introducing it and the clipboard result
+go to stderr, so `copilotkit channels setup > prompt.txt` gives you the payload
+and nothing else.
+
+The install runs first, and the command stops if it fails. A prompt that points
+at a skill which is not there would send the agent to set the provider up from
+memory against a live workspace, which is the outcome the prompt exists to
+prevent.
+
+The install asks you nothing. It pins the skill and every detected coding agent,
+so it runs to completion in a script or a non-TTY shell rather than stopping on a
+picker.
+
+Only `channels-setup` is installed, not every CopilotKit skill. To add the rest:
 
 ```bash
-npx copilotkit@latest skills install --skill setup-slack-channel
+npx copilotkit@latest skills install
 ```
 
-`channels setup` does not install or check for the skill, so the prompt itself
-tells the agent to stop and ask for that command if the skill is missing —
-rather than fall back to setting Slack up from memory against a live workspace.
-
-`copilotkit skills onboard --channels` does both in one pass — installs the
-skills, signs you in, and hands over the same prompt.
+`copilotkit skills onboard --channels` installs the skills, signs you in, and
+hands over the same prompt.
 
-`channels setup` reaches no server and provisions nothing. It needs no hosted
-project and no sign-in, so it works from any directory.
+`channels setup` selects no hosted project and provisions nothing, so it needs no
+sign-in and works from any directory. Installing the skill is the only thing it
+reaches out for.
 
 `channels status` compares three things that all have to agree — your declared
 configuration, your project's source, and the server — and names whichever one is

package/cli-build-info.json

@@ -2,20 +2,20 @@
   "schemaVersion": 1,
   "package": {
     "name": "copilotkit",
-    "version": "4.6.0"
+    "version": "4.8.0"
   },
   "intelligence": {
-    "commit": "bbe66a43632d05b5206cebdf49518d7335cc0f78"
+    "commit": "9b3d51575a8ad5fcbe2a24f898b6c33b3f8d5239"
   },
   "copilotKit": {
-    "submittedInput": "bc80efb17f5b729cc96a50cbbefca163079dc781",
-    "commit": "bc80efb17f5b729cc96a50cbbefca163079dc781"
+    "submittedInput": "b30527ca8a430490ba3b8866304f1451baa252af",
+    "commit": "b30527ca8a430490ba3b8866304f1451baa252af"
   },
   "channel": "production",
-  "triggeringActor": "MikeRyanDev",
+  "triggeringActor": "BenTaylorDev",
   "workflow": {
-    "runId": "30914059582",
-    "runUrl": "https://github.com/CopilotKit/Intelligence/actions/runs/30914059582"
+    "runId": "31015215100",
+    "runUrl": "https://github.com/CopilotKit/Intelligence/actions/runs/31015215100"
   },
   "validationResult": "passed",
   "ag2": {
@@ -24,5 +24,5 @@
     "revision": "main",
     "pinned": false
   },
-  "builtAt": "2026-08-04T13:31:09Z"
+  "builtAt": "2026-08-05T14:28:27Z"
 }

package/index.js

@@ -87,14 +87,14 @@ function getTelemetryEndpointUrl() {
 }
 function getBuildInfo() {
   return {
-    version: true ? "4.6.0" : "dev",
-    buildNumber: true ? "30914059582" : "dev",
-    commitSha: true ? "bbe66a43632d05b5206cebdf49518d7335cc0f78" : "dev",
+    version: true ? "4.8.0" : "dev",
+    buildNumber: true ? "31015215100" : "dev",
+    commitSha: true ? "9b3d51575a8ad5fcbe2a24f898b6c33b3f8d5239" : "dev",
     copilotKitCommit: getTemplateRef()
   };
 }
 function getTemplateRef() {
-  return true ? "bc80efb17f5b729cc96a50cbbefca163079dc781" : "main";
+  return true ? "b30527ca8a430490ba3b8866304f1451baa252af" : "main";
 }
 function getC15tBackendUrl() {
   return true ? "https://calm-hazelnut-joy-copilotkit.inth.app" : "";
@@ -460,7 +460,7 @@ function formatIntelligenceUnavailableError(framework) {
     ...THREADS_FRAMEWORKS
   ].join(", ")}.`;
 }
-var AGENT_FRAMEWORKS, FRAMEWORK_ALIASES, FRAMEWORK_EMOJI, FRAMEWORK_CHOICES, TEMPLATE_REPOS, UV_PREREQUISITE, DOTNET_PREREQUISITE, PYTHON3_PREREQUISITE, OPENAI_ENV_KEY, ANTHROPIC_ENV_KEY, GOOGLE_ENV_KEY, COPILOTKIT_LICENSE_ENV_KEY, FRAMEWORK_TEMPLATES, THREADS_FRAMEWORKS;
+var AGENT_FRAMEWORKS, FRAMEWORK_ALIASES, FRAMEWORK_EMOJI, FRAMEWORK_CHOICES, TEMPLATE_REPOS, UV_PREREQUISITE, DOTNET_PREREQUISITE, PYTHON3_PREREQUISITE, OPENAI_ENV_KEY, ANTHROPIC_ENV_KEY, GOOGLE_ENV_KEY, COPILOTKIT_LICENSE_ENV_KEY, FRAMEWORK_TEMPLATES, THREADS_FRAMEWORKS, FRAMEWORK_LANGUAGE, CHANNEL_HOST_FRAMEWORKS, INIT_CHANNEL_NONE;
 var init_types = __esm({
   "apps/cli/src/types.ts"() {
     "use strict";
@@ -805,6 +805,49 @@ var init_types = __esm({
       "a2ui",
       "opengenui"
     ]);
+    FRAMEWORK_LANGUAGE = {
+      "langgraph-py": "python",
+      "langgraph-js": "typescript",
+      "claude-sdk-typescript": "typescript",
+      "claude-sdk-python": "python",
+      flows: "python",
+      mastra: "typescript",
+      "pydantic-ai": "python",
+      llamaindex: "python",
+      agno: "python",
+      ag2: "python",
+      adk: "python",
+      "adk-angular": "python",
+      a2a: "typescript",
+      "aws-strands-py": "python",
+      "microsoft-agent-framework-dotnet": "dotnet",
+      "microsoft-agent-framework-py": "python",
+      "mcp-apps": "typescript",
+      "agentcore-langgraph": "python",
+      "agentcore-strands": "python",
+      a2ui: "python",
+      opengenui: "python"
+    };
+    CHANNEL_HOST_FRAMEWORKS = /* @__PURE__ */ new Set([
+      "langgraph-py",
+      "langgraph-js",
+      "claude-sdk-typescript",
+      "claude-sdk-python",
+      "flows",
+      "mastra",
+      "pydantic-ai",
+      "llamaindex",
+      "agno",
+      "adk",
+      "a2a",
+      "aws-strands-py",
+      "microsoft-agent-framework-dotnet",
+      "microsoft-agent-framework-py",
+      "mcp-apps",
+      "a2ui",
+      "opengenui"
+    ]);
+    INIT_CHANNEL_NONE = "none";
   }
 });
 
@@ -847,9 +890,21 @@ function initTelemetryBase(invokedAs, flags) {
     command: "init",
     subcommand: subcommandForInit(flags),
     invoked_as: invokedAs,
-    mock_mode: "none"
+    mock_mode: "none",
+    channel_flag: channelFlagFor(flags)
   };
 }
+function channelFlagFor(flags) {
+  switch (flags.channel) {
+    case "slack":
+    case "teams":
+      return flags.channel;
+    case "none":
+      return "declined";
+    default:
+      return "unset";
+  }
+}
 function resolveMockSubcommand(raw2) {
   if (raw2 === "enable" || raw2 === "disable")
     return raw2;
@@ -94019,6 +94074,137 @@ var init_license = __esm({
   }
 });
 
+// apps/cli/src/commands/framework-catalog.ts
+function listFrameworks() {
+  return [...AGENT_FRAMEWORKS].sort((left, right) => left.localeCompare(right)).map((id) => ({
+    id,
+    label: LABELS_WITHOUT_EMOJI.get(id) ?? id,
+    aliases: ALIASES_BY_FRAMEWORK.get(id) ?? [],
+    language: FRAMEWORK_LANGUAGE[id],
+    supportsIntelligence: THREADS_FRAMEWORKS.has(id),
+    supportsMock: isMockSupported(id),
+    supportsChannels: CHANNEL_HOST_FRAMEWORKS.has(id),
+    environment: FRAMEWORK_TEMPLATES[id].environment
+  }));
+}
+var LABELS_WITHOUT_EMOJI, ALIASES_BY_FRAMEWORK;
+var init_framework_catalog = __esm({
+  "apps/cli/src/commands/framework-catalog.ts"() {
+    "use strict";
+    init_types();
+    init_mock_llm();
+    LABELS_WITHOUT_EMOJI = new Map(
+      FRAMEWORK_CHOICES.map((choice) => {
+        const emoji3 = FRAMEWORK_EMOJI[choice.value];
+        const label = choice.label.startsWith(`${emoji3} `) ? choice.label.slice(emoji3.length + 1) : choice.label;
+        return [choice.value, label];
+      })
+    );
+    ALIASES_BY_FRAMEWORK = /* @__PURE__ */ new Map();
+    for (const [alias, framework] of Object.entries(FRAMEWORK_ALIASES)) {
+      const existing = ALIASES_BY_FRAMEWORK.get(framework);
+      if (existing === void 0) {
+        ALIASES_BY_FRAMEWORK.set(framework, [alias]);
+      } else {
+        existing.push(alias);
+      }
+    }
+  }
+});
+
+// apps/cli/src/commands/framework-list.ts
+var framework_list_exports = {};
+__export(framework_list_exports, {
+  renderFrameworkJson: () => renderFrameworkJson,
+  renderFrameworkTable: () => renderFrameworkTable,
+  runFrameworkList: () => runFrameworkList
+});
+function acceptedFlags(framework) {
+  const flags = [
+    framework.supportsIntelligence ? "-i" : void 0,
+    framework.supportsMock ? "--mock" : void 0,
+    framework.supportsChannels ? "--channel" : void 0
+  ].filter((flag) => flag !== void 0);
+  return flags.length === 0 ? "\u2014" : flags.join(" ");
+}
+function renderFrameworkTable(frameworks) {
+  if (frameworks.length === 0) {
+    return "No agent frameworks are available.\n";
+  }
+  const idWidth = Math.max(...frameworks.map((one) => one.id.length));
+  const languageWidth = Math.max(
+    ...frameworks.map((one) => one.language.length)
+  );
+  const labelWidth = Math.max(...frameworks.map((one) => one.label.length));
+  const rows = frameworks.map((framework) => {
+    const emoji3 = FRAMEWORK_EMOJI[framework.id];
+    return `  ${framework.id.padEnd(idWidth)}  ${framework.language.padEnd(
+      languageWidth
+    )}  ${emoji3} ${framework.label.padEnd(labelWidth)}  ${acceptedFlags(
+      framework
+    )}`;
+  });
+  const aliased = frameworks.filter((one) => one.aliases.length > 0);
+  const withEnvironment = frameworks.filter(
+    (one) => one.environment.length > 0
+  );
+  const notes = [
+    "Flags shown are the ones each framework accepts: -i (Intelligence threads),",
+    "--mock (keyless mock model), --channel (starter ships a managed Channel host)."
+  ];
+  if (aliased.length > 0) {
+    const pairs2 = aliased.flatMap(
+      (one) => one.aliases.map((alias) => `${alias} \u2192 ${one.id}`)
+    );
+    notes.push(`Accepted aliases: ${pairs2.join(", ")}.`);
+  }
+  if (withEnvironment.length > 0) {
+    const frameworksByKey = /* @__PURE__ */ new Map();
+    for (const framework of withEnvironment) {
+      for (const { key } of framework.environment) {
+        const existing = frameworksByKey.get(key);
+        if (existing === void 0) {
+          frameworksByKey.set(key, [framework.id]);
+        } else {
+          existing.push(framework.id);
+        }
+      }
+    }
+    notes.push("Vendor keys each framework reads from .env:");
+    for (const [key, ids] of [...frameworksByKey.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
+      notes.push(`  ${key}  ${ids.join(", ")}`);
+    }
+  }
+  return `Agent frameworks \u2014 pass one to \`copilotkit init -f <id>\`:
+
+${rows.join(
+    "\n"
+  )}
+
+${notes.join("\n")}
+`;
+}
+function renderFrameworkJson(frameworks) {
+  return `${JSON.stringify({ frameworks }, null, 2)}
+`;
+}
+async function runFrameworkList(options) {
+  const frameworks = listFrameworks();
+  process.stdout.write(
+    options.json ? renderFrameworkJson(frameworks) : renderFrameworkTable(frameworks)
+  );
+  return Promise.resolve();
+}
+var init_framework_list = __esm({
+  "apps/cli/src/commands/framework-list.ts"() {
+    "use strict";
+    init_framework_catalog();
+    init_types();
+  }
+});
+
 // apps/cli/src/services/project-config.ts
 import * as fs15 from "node:fs";
 import * as path12 from "node:path";
@@ -94972,9 +95158,9 @@ function buildSkillsOnboardPrompt() {
   return SKILLS_ONBOARD_AGENT_PROMPT;
 }
 function buildChannelsSetupPrompt() {
-  return CHANNELS_SLACK_SETUP_PROMPT;
+  return CHANNELS_SETUP_PROMPT;
 }
-var SKILLS_ONBOARD_AGENT_PROMPT, CHANNELS_SLACK_SETUP_PROMPT;
+var SKILLS_ONBOARD_AGENT_PROMPT, CHANNELS_SETUP_SKILL, CHANNELS_SETUP_PROMPT;
 var init_agent_prompt = __esm({
   "apps/cli/src/services/agent-prompt.ts"() {
     "use strict";
@@ -94987,23 +95173,8 @@ Use the copilotkit-setup skill to:
 4. Get a working chat integration.
 
 Start by inspecting my repo, then walk me through the setup.`;
-    CHANNELS_SLACK_SETUP_PROMPT = `Help me connect this CopilotKit agent to Slack so it answers in a real channel.
-
-Use the \`setup-slack-channel\` skill as your instructions \u2014 read it before you plan anything, and follow it rather than working from memory of how Slack apps usually work.
-
-If \`setup-slack-channel\` is not installed in this repo, stop and tell me to run \`npx copilotkit@latest skills install --skill setup-slack-channel\` before you do anything else. Do not attempt the setup without it.
-
-Before your first step, tell me which mode you are in:
-- You can drive a browser yourself. Then do so, and confirm with me before each consequential change in a live account \u2014 creating the Slack app, attaching the adapter, issuing a key.
-- You cannot. Then say so plainly and walk me through the browser steps one at a time, waiting for me to confirm each before you continue.
-
-Do not guess which one you are. Check what tools you actually have.
-
-Two rules for the whole run:
-- Never ask me to paste a token, signing secret, or API key into this conversation. They go into the Intelligence dashboard and my \`.env\`, typed by me.
-- Do not report success until all three of the skill's gates hold. "The runtime started" is not one of them.
-
-Start by reading the skill, then tell me what you found in my repo and what you plan to do.`;
+    CHANNELS_SETUP_SKILL = "channels-setup";
+    CHANNELS_SETUP_PROMPT = `Use the \`${CHANNELS_SETUP_SKILL}\` skill to set up a Channel for this project.`;
   }
 });
 
@@ -228835,19 +229006,19 @@ import { createRequire as topLevelCreateRequire86 } from "module";
 function mapLanguage(lang) {
   switch (lang) {
     case CodeExecutionLanguage.PYTHON:
-      return import_types7.Language.LANGUAGE_PYTHON;
+      return import_types9.Language.LANGUAGE_PYTHON;
     case CodeExecutionLanguage.JAVASCRIPT:
-      return import_types7.Language.LANGUAGE_JAVASCRIPT;
+      return import_types9.Language.LANGUAGE_JAVASCRIPT;
     default:
       throw new Error(`Unsupported language for Agent Engine Sandbox: ${lang}`);
   }
 }
-var import_vertexai, import_types7, require87, __defProp3, __getOwnPropDesc3, __decorateClass2, SANDBOX_PATTERN, ENGINE_PATTERN, DEFAULT_MAX_ATTEMPTS, DEFAULT_SANDBOX_TTL, DEFAULT_SANDBOX_DISPLAY_NAME, DEFAULT_ENGINE_DISPLAY_NAME, AgentEngineSandboxCodeExecutor;
+var import_vertexai, import_types9, require87, __defProp3, __getOwnPropDesc3, __decorateClass2, SANDBOX_PATTERN, ENGINE_PATTERN, DEFAULT_MAX_ATTEMPTS, DEFAULT_SANDBOX_TTL, DEFAULT_SANDBOX_DISPLAY_NAME, DEFAULT_ENGINE_DISPLAY_NAME, AgentEngineSandboxCodeExecutor;
 var init_agent_engine_sandbox_code_executor = __esm({
   "node_modules/.pnpm/@google+adk@1.3.0_@bufbuild+protobuf@2.12.1_@cfworker+json-schema@4.1.1_@grpc+grpc-js@1.14.4__5mkmwgy3xddtjib6vsxkdydt4e/node_modules/@google/adk/dist/esm/code_executors/agent_engine_sandbox_code_executor.js"() {
     "use strict";
     import_vertexai = __toESM(require_src17(), 1);
-    import_types7 = __toESM(require_types3(), 1);
+    import_types9 = __toESM(require_types3(), 1);
     init_experimental();
     init_file_utils();
     init_logger();
@@ -356952,6 +357123,77 @@ var init_init_flow = __esm({
   }
 });
 
+// apps/cli/src/commands/init-channel-flag.ts
+var init_channel_flag_exports = {};
+__export(init_channel_flag_exports, {
+  INIT_CHANNEL_NONE: () => INIT_CHANNEL_NONE,
+  channelFlagUnsupportedError: () => channelFlagUnsupportedError,
+  channelOfferFromFlag: () => channelOfferFromFlag,
+  formatChannelUnsupportedError: () => formatChannelUnsupportedError,
+  resolveInitChannelFlag: () => resolveInitChannelFlag
+});
+function resolveInitChannelFlag(input) {
+  if (input.value === void 0) {
+    return { status: "ok", channel: null };
+  }
+  const value = input.value;
+  if (!ACCEPTED_VALUES.includes(value)) {
+    return {
+      status: "invalid",
+      message: `Unknown channel: "${value}". Expected one of: ${ACCEPTED_VALUES.join(
+        ", "
+      )}.
+Run \`copilotkit channels providers\` to see what each provider needs.`
+    };
+  }
+  if (value === INIT_CHANNEL_NONE) {
+    return { status: "ok", channel: INIT_CHANNEL_NONE };
+  }
+  const framework = input.framework === void 0 ? void 0 : resolveFrameworkAlias(input.framework);
+  if (framework !== void 0 && isAgentFramework(framework) && !CHANNEL_HOST_FRAMEWORKS.has(framework)) {
+    return {
+      status: "invalid",
+      message: formatChannelUnsupportedError(framework, value)
+    };
+  }
+  return { status: "ok", channel: value };
+}
+function formatChannelUnsupportedError(framework, provider) {
+  return `The ${framework} starter ships no Channel host, so --channel cannot be used with it.
+Run \`copilotkit framework list\` to see which frameworks accept --channel, or scaffold without it and run \`copilotkit channels add --adapter ${provider}\` against a runtime you host yourself.`;
+}
+function channelOfferFromFlag(channel2) {
+  if (channel2 === null) {
+    return void 0;
+  }
+  const adapter2 = channel2 === INIT_CHANNEL_NONE ? void 0 : channel2;
+  return () => Promise.resolve(adapter2);
+}
+function channelFlagUnsupportedError(channel2, framework) {
+  if (channel2 === null || channel2 === INIT_CHANNEL_NONE) {
+    return void 0;
+  }
+  if (!isAgentFramework(framework)) {
+    return void 0;
+  }
+  if (CHANNEL_HOST_FRAMEWORKS.has(framework)) {
+    return void 0;
+  }
+  return formatChannelUnsupportedError(framework, channel2);
+}
+var ACCEPTED_VALUES;
+var init_init_channel_flag = __esm({
+  "apps/cli/src/commands/init-channel-flag.ts"() {
+    "use strict";
+    init_channels();
+    init_types();
+    ACCEPTED_VALUES = [
+      ...CHANNEL_ADAPTERS,
+      INIT_CHANNEL_NONE
+    ];
+  }
+});
+
 // apps/cli/src/services/channel-artifacts.ts
 import * as fs26 from "node:fs";
 import * as path25 from "node:path";
@@ -358292,6 +358534,36 @@ var init_channel_credential_prompt = __esm({
   }
 });
 
+// apps/cli/src/services/channel-provider-catalog.ts
+function listChannelProviders() {
+  return CHANNEL_ADAPTERS.map((id) => ({
+    id,
+    label: CHANNEL_PROVIDER_LABELS[id],
+    credentialFields: CREDENTIAL_FIELDS_BY_PROVIDER[id].map((field) => {
+      const label = credentialFieldLabel(field);
+      return { field, name: label.name, where: label.where };
+    }),
+    supportsProvisioning: id === "teams",
+    requiresInvite: id === "slack"
+  }));
+}
+var CHANNEL_PROVIDER_LABELS, CREDENTIAL_FIELDS_BY_PROVIDER;
+var init_channel_provider_catalog = __esm({
+  "apps/cli/src/services/channel-provider-catalog.ts"() {
+    "use strict";
+    init_channels();
+    init_channel_credentials();
+    CHANNEL_PROVIDER_LABELS = Object.freeze({
+      slack: "Slack",
+      teams: "Microsoft Teams"
+    });
+    CREDENTIAL_FIELDS_BY_PROVIDER = Object.freeze({
+      slack: ["channelToken", "signingSecret"],
+      teams: ["clientId", "clientSecret", "tenantId"]
+    });
+  }
+});
+
 // apps/cli/src/ui/channel-offer.tsx
 function ChannelOffer(props) {
   const indexRef = (0, import_react47.useRef)(0);
@@ -358355,10 +358627,11 @@ var init_channel_offer = __esm({
     await init_build2();
     import_react47 = __toESM(require_react(), 1);
     init_theme();
+    init_channel_provider_catalog();
     import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
     CHOICES2 = [
-      { adapter: "slack", label: "Slack" },
-      { adapter: "teams", label: "Microsoft Teams" },
+      { adapter: "slack", label: CHANNEL_PROVIDER_LABELS.slack },
+      { adapter: "teams", label: CHANNEL_PROVIDER_LABELS.teams },
       { adapter: void 0, label: "Not now" }
     ];
   }
@@ -359029,6 +359302,17 @@ function ScaffoldProgress({
   const installAlreadyRanRef = (0, import_react48.useRef)(false);
   const [credentialRequest, setCredentialRequest] = (0, import_react48.useState)(null);
   const [attachingChannel, setAttachingChannel] = (0, import_react48.useState)(false);
+  const channelFlagError = (0, import_react48.useMemo)(
+    () => options.framework === null ? void 0 : channelFlagUnsupportedError(
+      options.channel ?? null,
+      options.framework
+    ),
+    [options.channel, options.framework]
+  );
+  const flagChannelOffer = (0, import_react48.useMemo)(
+    () => channelOfferFromFlag(options.channel ?? null),
+    [options.channel]
+  );
   const scaffoldDependencies = (0, import_react48.useMemo)(
     () => ({
       ...defaultInitScaffoldDependencies,
@@ -359048,18 +359332,32 @@ function ScaffoldProgress({
       // render branch, so a non-interactive run has nothing to drive it and would
       // wait on a deferred that never settles -- an init that hangs forever is far
       // worse than an init that simply does not offer a Channel.
-      ...(dependencies?.isVendorKeyPromptInteractive ?? vendorKeyPromptInteractive)() ? {
-        offerChannelAdapter: () => new Promise((resolve4) => {
+      //
+      // A `--channel` value overrides that entirely: the offer is pre-answered,
+      // so it resolves immediately, nothing renders, and there is no keypress to
+      // mistime. That is what makes the flag safe under a pty, where stdin looks
+      // interactive but nobody is watching and the cursor starts on Slack.
+      ...flagChannelOffer !== void 0 || (dependencies?.isVendorKeyPromptInteractive ?? vendorKeyPromptInteractive)() ? {
+        offerChannelAdapter: flagChannelOffer ?? (() => new Promise((resolve4) => {
           channelOfferDeferredRef.current = { resolve: resolve4 };
-        }),
+        })),
         setUpChannel: (input) => runInitChannelSetup(input),
-        completeChannelSetup: (input) => runInitChannelCompletion(input)
+        // Guided completion is a PROMPT -- it renders ChannelCredentialPrompt
+        // and asks for a provider secret -- so it is wired only for a run that
+        // may legitimately prompt. Gating it on interactivity alone was wrong:
+        // under a pty vendorKeyPromptInteractive() is true, so a `--channel`
+        // run had its offer suppressed and was then asked for a Slack token
+        // anyway. A flag-driven Channel stays silent end to end and reports
+        // what is outstanding instead.
+        ...flagChannelOffer === void 0 ? {
+          completeChannelSetup: (input) => runInitChannelCompletion(input)
+        } : {}
       } : {},
       // Test-injected deps win over the inline wiring above; the production
       // shell (InitApp) passes none, so the inline selectHostedProject stands.
       ...dependencies
     }),
-    [browserLogin.runLogin, dependencies]
+    [browserLogin.runLogin, dependencies, flagChannelOffer]
   );
   (0, import_react48.useEffect)(() => {
     if (phase === "success" || phase === "error") {
@@ -359091,6 +359389,16 @@ function ScaffoldProgress({
   }, [phase, scaffoldResult]);
   (0, import_react48.useEffect)(() => {
     let cancelled = false;
+    if (channelFlagError !== void 0) {
+      const error48 = new Error(channelFlagError);
+      error48.displayed = true;
+      scaffoldErrorRef.current = error48;
+      setErrorMessage(channelFlagError);
+      setPhase("error");
+      return () => {
+        cancelled = true;
+      };
+    }
     async function run() {
       const result = await scaffoldInitProject(
         options,
@@ -359500,18 +359808,20 @@ function InitApp({
   initialFramework,
   noBanner = false,
   initialMock = false,
+  initialChannel = null,
   renderScaffoldProgress = renderDefaultScaffoldProgress,
   onIntelligenceSelected,
   onFrameworkSelected,
   telemetry
 }) {
   const mock = initialMock === true;
-  const prefilled = resolvePrefilledOptions(
+  const prefilledBase = resolvePrefilledOptions(
     initialName,
     initialIntelligence,
     initialFramework,
     mock
   );
+  const prefilled = prefilledBase === null ? null : { ...prefilledBase, channel: initialChannel };
   const [options, setOptions] = (0, import_react48.useState)(prefilled);
   (0, import_react48.useEffect)(() => {
     if (prefilled !== null) {
@@ -359545,7 +359855,7 @@ function InitApp({
           onFrameworkSelected,
           onComplete: (resolved) => {
             if (resolved !== null) {
-              setOptions({ ...resolved, mock });
+              setOptions({ ...resolved, mock, channel: initialChannel });
             }
           }
         }
@@ -359588,6 +359898,7 @@ async function runInit(flags, callbacks) {
         initialIntelligence,
         initialFramework,
         initialMock: flags.mock ?? false,
+        initialChannel: flags.channel ?? null,
         noBanner: flags.noBanner === true,
         onIntelligenceSelected: callbacks?.onIntelligenceSelected,
         onFrameworkSelected: callbacks?.onFrameworkSelected,
@@ -359626,6 +359937,7 @@ var init_init = __esm({
     await init_spinner();
     await init_success_text();
     await init_channels_events();
+    init_init_channel_flag();
     init_config();
     init_init_channel_setup();
     await init_channel_completion();
@@ -360412,6 +360724,79 @@ var init_channels_preflight = __esm({
   }
 });
 
+// apps/cli/src/commands/channel-providers.ts
+var channel_providers_exports = {};
+__export(channel_providers_exports, {
+  listChannelProviders: () => listChannelProviders,
+  renderChannelProviderJson: () => renderChannelProviderJson,
+  renderChannelProviderTable: () => renderChannelProviderTable,
+  runChannelProviders: () => runChannelProviders
+});
+function renderChannelProviderTable(providers) {
+  const blocks = providers.map((provider) => {
+    const header = `  ${provider.id}  (${provider.label})`;
+    const notes = [];
+    if (provider.supportsProvisioning) {
+      notes.push(
+        `    The CLI can create the provider-side app for you: \`channels add --adapter ${provider.id} --provision\`.`
+      );
+    } else {
+      notes.push(
+        `    You create the ${provider.label} app yourself; the CLI attaches to it.`
+      );
+    }
+    if (provider.requiresInvite) {
+      notes.push(
+        "    Invite the bot to a conversation after attaching. Installed but",
+        "    invited nowhere, it answers nothing and looks like a broken Channel."
+      );
+    }
+    const credentials = provider.credentialFields.map(
+      (credential) => `      ${credential.field} \u2014 "${credential.name}", from ${credential.where}`
+    );
+    return [
+      header,
+      ...notes,
+      "    Credentials it will ask for:",
+      ...credentials
+    ].join("\n");
+  });
+  return `Chat providers a managed Channel can use:
+
+${blocks.join("\n\n")}
+
+Pass one to \`channels add --adapter <id>\` or \`init --channel <id>\`.
+No flag accepts a credential value: credentials are read from your .env, from
+a named variable, or from a JSON document on stdin.
+`;
+}
+function renderChannelProviderJson(providers) {
+  return `${JSON.stringify(
+    {
+      envelopeVersion: CHANNELS_ENVELOPE_VERSION,
+      command: "channels providers",
+      providers
+    },
+    null,
+    2
+  )}
+`;
+}
+async function runChannelProviders(options) {
+  const providers = listChannelProviders();
+  process.stdout.write(
+    options.json ? renderChannelProviderJson(providers) : renderChannelProviderTable(providers)
+  );
+  return Promise.resolve();
+}
+var init_channel_providers = __esm({
+  "apps/cli/src/commands/channel-providers.ts"() {
+    "use strict";
+    init_src11();
+    init_channel_provider_catalog();
+  }
+});
+
 // apps/cli/src/commands/channels.ts
 var channels_exports = {};
 __export(channels_exports, {
@@ -360521,13 +360906,44 @@ async function runChannelsSetup(argv) {
     options: { "no-clipboard": { type: "boolean" } },
     strict: true
   });
+  recordTelemetryEvent({
+    properties: {
+      command: "channels",
+      subcommand: "setup",
+      outcome: "started"
+    }
+  });
+  try {
+    await installCopilotKitSkills({
+      skills: [CHANNELS_SETUP_SKILL],
+      yes: true
+    });
+  } catch (error48) {
+    recordTelemetryEvent({
+      properties: {
+        command: "channels",
+        subcommand: "setup",
+        outcome: "failed",
+        error_code: classifyError(error48)
+      }
+    });
+    throw error48;
+  }
   const prompt = buildChannelsSetupPrompt();
-  process.stdout.write(`${prompt}
-`);
-  const copied = parsed.values["no-clipboard"] === true ? false : await copyToClipboard(prompt);
   process.stderr.write(
-    copied ? "\nCopied to your clipboard. Paste it into Claude (or your coding agent) to start.\n" : "\nCopy the prompt above and paste it into Claude (or your coding agent) to start.\n"
+    "Paste this prompt into your coding agent:\n\n"
   );
+  process.stdout.write(`${prompt}
+`);
+  const skipClipboard = parsed.values["no-clipboard"] === true;
+  const copied = skipClipboard ? false : await copyToClipboard(prompt);
+  if (copied) {
+    process.stderr.write("\n\u2713 Copied to your clipboard.\n");
+  } else if (!skipClipboard) {
+    process.stderr.write(
+      "\nCould not copy to your clipboard \u2014 copy the prompt above.\n"
+    );
+  }
   recordTelemetryEvent({
     properties: {
       command: "channels",
@@ -360550,6 +360966,51 @@ async function runChannels(argv) {
     process.exitCode = 1;
     return;
   }
+  if (subcommand === "providers") {
+    let providersJson = false;
+    try {
+      const providersArgs = parseArgs2({
+        allowPositionals: false,
+        args: [...argv.slice(1)],
+        options: { json: { type: "boolean" } },
+        strict: true
+      });
+      providersJson = providersArgs.values.json === true;
+    } catch (error48) {
+      recordTelemetryEvent({
+        properties: {
+          command: "channels",
+          subcommand: "providers",
+          outcome: "failed",
+          error_code: "validation"
+        }
+      });
+      process.stderr.write(
+        `${error48 instanceof Error ? error48.message : String(error48)}
+Usage: copilotkit channels providers [--json]
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    recordTelemetryEvent({
+      properties: {
+        command: "channels",
+        subcommand: "providers",
+        outcome: "started"
+      }
+    });
+    const { runChannelProviders: runChannelProviders2 } = await Promise.resolve().then(() => (init_channel_providers(), channel_providers_exports));
+    await runChannelProviders2({ json: providersJson });
+    recordTelemetryEvent({
+      properties: {
+        command: "channels",
+        subcommand: "providers",
+        outcome: "succeeded"
+      }
+    });
+    return;
+  }
   const parsed = parseArgs2({
     allowPositionals: true,
     args: [...argv.slice(1)],
@@ -360797,6 +361258,7 @@ var init_channels2 = __esm({
     init_channels();
     init_config();
     init_agent_prompt();
+    init_skills_install();
     init_api_client();
     init_clipboard();
     init_config_service();
@@ -360815,6 +361277,7 @@ var init_channels2 = __esm({
     init_channels_render();
     init_channels_preflight();
     await init_channels_events();
+    init_event_properties();
     await init_telemetry();
     init_project_config();
     init_src11();
@@ -360829,6 +361292,7 @@ var init_channels2 = __esm({
     SUBCOMMANDS = [
       "add",
       "list",
+      "providers",
       "rotate",
       "status"
     ];
@@ -361350,7 +361814,9 @@ Commands:
   license list           List CopilotKit license metadata
   license ls             Alias of license list
   project select         Select or create a hosted Intelligence project
+  framework list         List the agent frameworks init accepts, and their flags
   channels               Set up managed Intelligence Channels (Slack, Teams)
+  channels providers     List the chat providers a Channel can use
   skills install         Install the CopilotKit agent skills
   skills onboard         Install skills and start agent-assisted onboarding
 ${isCliFlagEnabled("cli.aimock-mock-mode") ? "  mock enable            Wire a scaffolded project to run keyless against a local mock LLM\n  mock disable           Restore a real vendor API key and remove mock wiring\n" : ""}  import [options]        Import ADK/LangGraph threads into Intelligence
@@ -361422,7 +361888,18 @@ Options:
                          persistence, insights) ships with every supported
                          framework and a free license is provisioned during init.
 ${isCliFlagEnabled("cli.aimock-mock-mode") ? `      --mock             Run keyless against a local mock LLM (supported: ${formatMockSupportedFrameworks()}).
-` : ""}      --no-banner        Suppress the CopilotKit welcome banner (used when a
+` : ""}      --channel <what>   Pre-answer the managed Channel offer: slack, teams, or
+                         none. With this flag the offer is never shown, so a
+                         scripted run cannot land on a provider by mistiming a
+                         keystroke. \`none\` declines it outright.
+
+                         Accepted only for frameworks whose starter ships a
+                         Channel host; run \`copilotkit framework list\` to see
+                         which, and \`copilotkit channels providers\` for what each
+                         provider will ask you for. A named provider is set up as
+                         far as it can go without credentials, then reports what
+                         is left -- it never prompts for a secret.
+      --no-banner        Suppress the CopilotKit welcome banner (used when a
                          parent tool, e.g. create-ag-ui-app, shows its own)
   -h, --help             Show help for init
 `,
@@ -361461,6 +361938,12 @@ Subcommands:
   add [name]             Declare a Channel, reconcile it, and report the next step
   status                 Compare your configuration, your code, and the server
   list                   List Channels and their attachment state
+  providers              List the chat providers a Channel can use, and the
+                         credentials each one asks for. Answers from a catalog
+                         compiled into this CLI: no project, no credentials, no
+                         API call, no TTY. Emits a catalog response rather than the
+                         operation envelope. Distinct from \`list\`, which reports
+                         YOUR Channels.
   rotate <name>          Explicitly replace stored provider credentials
   setup                  Print a setup prompt for your coding agent and copy it
                          to the clipboard, then paste it into Claude
@@ -361516,6 +361999,44 @@ persist the choice to .copilotkit/project.json.
 
 Options:
   -h, --help             Show help for project select
+`,
+  framework: `Usage: copilotkit framework <subcommand>
+
+Inspect the agent frameworks \`copilotkit init\` can scaffold.
+
+Subcommands:
+  list                   List every framework and the init flags it accepts
+
+Options:
+  -h, --help             Show help for framework
+`,
+  "framework-list": `Usage: copilotkit framework list [options]
+
+List every agent framework \`copilotkit init -f <id>\` accepts, with the id to
+pass, the language its agent is written in, and the init flags that framework
+supports.
+
+Answers from a catalog compiled into this CLI binary, so it needs no API call, no
+authentication and no TTY, and cannot fail once the arguments parse \u2014 there is no
+signed-out or offline case to handle. (Anonymous usage telemetry is still sent
+unless you have opted out; it is best-effort and never blocks or alters the
+output.)
+
+Each row lists only the flags that framework accepts:
+  -i                     Intelligence threads are available to license
+  --mock                 A keyless mock model can stand in for a vendor key
+  --channel              The starter ships a managed Channel host, so
+                         \`init --channel\` can serve Slack or Teams
+
+Frameworks needing a vendor API key are footnoted with the variable name, so you
+can have the value ready before scaffolding rather than meeting the prompt.
+
+Options:
+  --json                 Emit a machine-readable payload as the ONLY thing on
+                         stdout, safe to pipe into a parser. Each entry adds the
+                         accepted \`-f\` aliases and whether each environment key
+                         is required.
+  -h, --help             Show help for framework list
 `,
   skills: `Usage: copilotkit skills <subcommand>
 
@@ -361714,6 +362235,12 @@ function resolveCommandHelpTopic(argv) {
     }
     return "project";
   }
+  if (command === "framework" || command === "frameworks") {
+    if (subcommand === "list" || subcommand === "ls") {
+      return "framework-list";
+    }
+    return "framework";
+  }
   if (command === "skills") {
     if (subcommand === "install") {
       return "skills-install";
@@ -361940,6 +362467,39 @@ ${HELP_TEXT_BY_TOPIC.root}`
     }
   );
 }
+async function runFrameworkCommand(argv) {
+  const subcommand = argv[0];
+  if (subcommand !== "list" && subcommand !== "ls") {
+    recordTelemetryEvent({
+      properties: {
+        command: "framework",
+        outcome: "failed",
+        error_code: "validation"
+      }
+    });
+    const lead = subcommand === void 0 ? "Error: copilotkit framework requires a subcommand (list).\n\n" : `Unknown framework subcommand: "${subcommand}"
+
+`;
+    process.stderr.write(`${lead}${HELP_TEXT_BY_TOPIC.framework}`);
+    await exitWithFlush(1);
+    return;
+  }
+  const parsed = parseArgs3({
+    args: [...argv.slice(1)],
+    options: {
+      json: { type: "boolean" }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  const { runFrameworkList: runFrameworkList2 } = await Promise.resolve().then(() => (init_framework_list(), framework_list_exports));
+  await withTelemetry(
+    { command: "framework", subcommand: "list" },
+    async () => {
+      await runFrameworkList2({ json: parsed.values["json"] === true });
+    }
+  );
+}
 async function runProjectCommand(argv) {
   const subcommand = argv[0];
   if (subcommand !== "select") {
@@ -362254,6 +362814,7 @@ var INIT_PARSE_OPTIONS = {
   intelligence: { type: "boolean", short: "i" },
   framework: { type: "string", short: "f" },
   mock: { type: "boolean" },
+  channel: { type: "string" },
   "no-banner": { type: "boolean" }
 };
 async function runInitCommand(invokedAs, argv) {
@@ -362271,8 +362832,29 @@ async function runInitCommand(invokedAs, argv) {
   const telemetryBase = initTelemetryBase(invokedAs, {
     intelligence,
     framework,
-    mock
+    mock,
+    // Raw, and read before validation on purpose: the base has to exist for the
+    // validation-failure event below to be reportable.
+    channel: parsed.values["channel"]
   });
+  const { resolveInitChannelFlag: resolveInitChannelFlag2 } = await Promise.resolve().then(() => (init_init_channel_flag(), init_channel_flag_exports));
+  const channelResolution = resolveInitChannelFlag2({
+    value: parsed.values["channel"],
+    framework: frameworkFlag
+  });
+  if (channelResolution.status === "invalid") {
+    recordTelemetryEvent({
+      properties: {
+        ...telemetryBase,
+        outcome: "failed",
+        error_code: "validation"
+      }
+    });
+    process.stderr.write(`Error: ${channelResolution.message}
+`);
+    await exitWithFlush(1);
+    return;
+  }
   if (!process.stdin.isTTY) {
     recordTelemetryEvent({
       properties: {
@@ -362320,6 +362902,7 @@ async function runInitCommand(invokedAs, argv) {
     intelligence,
     framework,
     mock,
+    channel: channelResolution.channel,
     noBanner: parsed.values["no-banner"]
   };
   await withTelemetry(telemetryBase, async (ctx) => {
@@ -362395,6 +362978,18 @@ var COMMAND_TABLE = {
       await runProjectCommand(argv);
     }
   },
+  framework: {
+    kind: "self",
+    run: async (argv) => {
+      await runFrameworkCommand(argv);
+    }
+  },
+  frameworks: {
+    kind: "self",
+    run: async (argv) => {
+      await runFrameworkCommand(argv);
+    }
+  },
   skills: {
     kind: "self",
     run: async (argv) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilotkit",
-  "version": "4.6.0",
+  "version": "4.8.0",
   "type": "module",
   "repository": {
     "type": "git",

package/release/release-tool.js

@@ -14683,7 +14683,7 @@ import * as path4 from "node:path";
 
 // apps/cli/src/config.ts
 function getTemplateRef() {
-  return true ? "bc80efb17f5b729cc96a50cbbefca163079dc781" : "main";
+  return true ? "b30527ca8a430490ba3b8866304f1451baa252af" : "main";
 }
 
 // apps/cli/src/services/agentcore-config.ts