copilotkit 4.7.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".

package/cli-build-info.json

@@ -2,20 +2,20 @@
   "schemaVersion": 1,
   "package": {
     "name": "copilotkit",
-    "version": "4.7.0"
+    "version": "4.8.0"
   },
   "intelligence": {
-    "commit": "932bad4f3c97b61dd0ee5c20b99362e302e5e48a"
+    "commit": "9b3d51575a8ad5fcbe2a24f898b6c33b3f8d5239"
   },
   "copilotKit": {
-    "submittedInput": "8e59bfd16b415b9f776a4742aa43942a8d02c2ef",
-    "commit": "8e59bfd16b415b9f776a4742aa43942a8d02c2ef"
+    "submittedInput": "b30527ca8a430490ba3b8866304f1451baa252af",
+    "commit": "b30527ca8a430490ba3b8866304f1451baa252af"
   },
   "channel": "production",
   "triggeringActor": "BenTaylorDev",
   "workflow": {
-    "runId": "30933084879",
-    "runUrl": "https://github.com/CopilotKit/Intelligence/actions/runs/30933084879"
+    "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-04T17:17:46Z"
+  "builtAt": "2026-08-05T14:28:27Z"
 }

package/index.js

@@ -87,14 +87,14 @@ function getTelemetryEndpointUrl() {
 }
 function getBuildInfo() {
   return {
-    version: true ? "4.7.0" : "dev",
-    buildNumber: true ? "30933084879" : "dev",
-    commitSha: true ? "932bad4f3c97b61dd0ee5c20b99362e302e5e48a" : "dev",
+    version: true ? "4.8.0" : "dev",
+    buildNumber: true ? "31015215100" : "dev",
+    commitSha: true ? "9b3d51575a8ad5fcbe2a24f898b6c33b3f8d5239" : "dev",
     copilotKitCommit: getTemplateRef()
   };
 }
 function getTemplateRef() {
-  return true ? "8e59bfd16b415b9f776a4742aa43942a8d02c2ef" : "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";
@@ -228820,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();
@@ -356937,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";
@@ -358277,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);
@@ -358340,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" }
     ];
   }
@@ -359014,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,
@@ -359033,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") {
@@ -359076,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,
@@ -359485,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) {
@@ -359530,7 +359855,7 @@ function InitApp({
           onFrameworkSelected,
           onComplete: (resolved) => {
             if (resolved !== null) {
-              setOptions({ ...resolved, mock });
+              setOptions({ ...resolved, mock, channel: initialChannel });
             }
           }
         }
@@ -359573,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,
@@ -359611,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();
@@ -360397,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, {
@@ -360566,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)],
@@ -360847,6 +361292,7 @@ var init_channels2 = __esm({
     SUBCOMMANDS = [
       "add",
       "list",
+      "providers",
       "rotate",
       "status"
     ];
@@ -361368,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
@@ -361440,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
 `,
@@ -361479,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
@@ -361534,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>
 
@@ -361732,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";
@@ -361958,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") {
@@ -362272,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) {
@@ -362289,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: {
@@ -362338,6 +362902,7 @@ async function runInitCommand(invokedAs, argv) {
     intelligence,
     framework,
     mock,
+    channel: channelResolution.channel,
     noBanner: parsed.values["no-banner"]
   };
   await withTelemetry(telemetryBase, async (ctx) => {
@@ -362413,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.7.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 ? "8e59bfd16b415b9f776a4742aa43942a8d02c2ef" : "main";
+  return true ? "b30527ca8a430490ba3b8866304f1451baa252af" : "main";
 }
 
 // apps/cli/src/services/agentcore-config.ts