The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { resolveProviderProbeTimeoutMs } from "@t3tools/provider-core/server/snapshotProbe"; |
| 2 | import { |
| 3 | type ModelCapabilities, |
| 4 | ProviderDriverKind, |
| 5 | type ProviderOptionDescriptor, |
| 6 | type ServerProviderAuth, |
| 7 | type ServerProviderModel, |
| 8 | } from "@t3tools/contracts"; |
| 9 | import type { KiroSettings } from "../settings.ts"; |
| 10 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 11 | import { createModelCapabilities } from "@t3tools/shared/model"; |
| 12 | import { resolveSpawnCommand } from "@t3tools/shared/shell"; |
| 13 | import type * as SecureRandom from "effect/crypto/SecureRandom"; |
| 14 | import * as DateTime from "effect/DateTime"; |
| 15 | import * as Effect from "effect/Effect"; |
| 16 | import * as Option from "effect/Option"; |
| 17 | import * as Result from "effect/Result"; |
| 18 | import * as Schema from "effect/Schema"; |
| 19 | import { ChildProcess, type ChildProcessSpawner } from "effect/process"; |
| 20 | |
| 21 | import { |
| 22 | KIRO_AGENT_CONFIG_ID, |
| 23 | KIRO_SUPPORTED_RUNTIME_MODES, |
| 24 | makeKiroAcpRuntime, |
| 25 | } from "./acpSupport.ts"; |
| 26 | import { |
| 27 | AUTH_PROBE_TIMEOUT_MS, |
| 28 | buildServerProvider, |
| 29 | COMPACT_SLASH_COMMAND, |
| 30 | isCommandMissingCause, |
| 31 | parseCliVersionResult, |
| 32 | buildSelectOptionDescriptor, |
| 33 | type ProviderProbeResult, |
| 34 | providerModelsFromSettings, |
| 35 | type ServerProviderDraft, |
| 36 | providerProbeEnvironment, |
| 37 | spawnAndCollect, |
| 38 | } from "@t3tools/provider-core/server/snapshotProbe"; |
| 39 | |
| 40 | const KIRO_DRIVER_KIND = ProviderDriverKind.make("kiro"); |
| 41 | const KIRO_PRESENTATION = { |
| 42 | displayName: "Kiro", |
| 43 | showInteractionModeToggle: false, |
| 44 | supportedRuntimeModes: KIRO_SUPPORTED_RUNTIME_MODES, |
| 45 | } as const; |
| 46 | const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({ optionDescriptors: [] }); |
| 47 | const KIRO_DEFAULT_MODEL_SLUG = "default"; |
| 48 | const KIRO_FALLBACK_DEFAULT_MODEL = "auto"; |
| 49 | const KIRO_BUILT_IN_MODELS: ReadonlyArray<ServerProviderModel> = [ |
| 50 | { |
| 51 | slug: KIRO_DEFAULT_MODEL_SLUG, |
| 52 | name: "Kiro default", |
| 53 | isCustom: false, |
| 54 | capabilities: EMPTY_CAPABILITIES, |
| 55 | }, |
| 56 | ]; |
| 57 | const KIRO_API_KEY_ENV = "KIRO_API_KEY"; |
| 58 | const VERSION_PROBE_TIMEOUT_MS = 10_000; |
| 59 | |
| 60 | /** |
| 61 | * The agent picker is not a model trait, but the composer reads options per |
| 62 | * model, so every model, custom ones included, carries it. |
| 63 | */ |
| 64 | const kiroModels = ( |
| 65 | settings: KiroSettings, |
| 66 | listed: ReadonlyArray<ServerProviderModel> = KIRO_BUILT_IN_MODELS, |
| 67 | agents?: ProviderOptionDescriptor, |
| 68 | ) => |
| 69 | providerModelsFromSettings(listed, settings.customModels, EMPTY_CAPABILITIES).map((model) => { |
| 70 | const descriptors = model.capabilities?.optionDescriptors ?? []; |
| 71 | return agents === undefined || descriptors.some((descriptor) => descriptor.id === agents.id) |
| 72 | ? model |
| 73 | : { |
| 74 | ...model, |
| 75 | capabilities: createModelCapabilities({ optionDescriptors: [...descriptors, agents] }), |
| 76 | }; |
| 77 | }); |
| 78 | |
| 79 | const snapshot = ( |
| 80 | settings: KiroSettings, |
| 81 | checkedAt: string, |
| 82 | probe: ProviderProbeResult, |
| 83 | listed?: ReadonlyArray<ServerProviderModel>, |
| 84 | agents?: ProviderOptionDescriptor, |
| 85 | ) => |
| 86 | buildServerProvider({ |
| 87 | // Gives the snapshot its version advisory; Kiro runs no enrichment pass. |
| 88 | driver: KIRO_DRIVER_KIND, |
| 89 | presentation: KIRO_PRESENTATION, |
| 90 | enabled: settings.enabled, |
| 91 | checkedAt, |
| 92 | models: kiroModels(settings, listed, agents), |
| 93 | // `/compact` runs `_kiro/session/compact`; see kiroCompactSession. |
| 94 | slashCommands: [COMPACT_SLASH_COMMAND], |
| 95 | probe, |
| 96 | }); |
| 97 | |
| 98 | export const buildInitialKiroProviderSnapshot = Effect.fn( |
| 99 | "KiroProvider.buildInitialKiroProviderSnapshot", |
| 100 | )(function* (settings: KiroSettings): Effect.fn.Return<ServerProviderDraft> { |
| 101 | const now = yield* DateTime.now; |
| 102 | return snapshot(settings, DateTime.formatIso(now), { |
| 103 | installed: settings.enabled, |
| 104 | version: null, |
| 105 | status: "warning", |
| 106 | auth: { status: "unknown" }, |
| 107 | message: settings.enabled |
| 108 | ? "Checking Kiro CLI availability..." |
| 109 | : "Kiro is disabled in T3 Code settings.", |
| 110 | }); |
| 111 | }); |
| 112 | |
| 113 | const runKiroCli = Effect.fn("KiroProvider.runKiroCli")(function* ( |
| 114 | settings: KiroSettings, |
| 115 | args: ReadonlyArray<string>, |
| 116 | environment: NodeJS.ProcessEnv, |
| 117 | ) { |
| 118 | const command = settings.binaryPath || "kiro-cli"; |
| 119 | const spawnCommand = yield* resolveSpawnCommand(command, args, { env: environment }); |
| 120 | return yield* spawnAndCollect( |
| 121 | command, |
| 122 | ChildProcess.make(spawnCommand.command, spawnCommand.args, { |
| 123 | env: environment, |
| 124 | shell: spawnCommand.shell, |
| 125 | }), |
| 126 | ); |
| 127 | }); |
| 128 | |
| 129 | const KiroWhoami = Schema.fromJsonString( |
| 130 | Schema.Struct({ |
| 131 | accountType: Schema.optional(Schema.NullOr(Schema.String)), |
| 132 | email: Schema.optional(Schema.NullOr(Schema.String)), |
| 133 | }), |
| 134 | ); |
| 135 | const decodeKiroWhoami = Schema.decodeUnknownOption(KiroWhoami); |
| 136 | |
| 137 | /** |
| 138 | * Reads `kiro-cli whoami --format json`: `{"account":null}` with exit 1 means |
| 139 | * signed out. Only the first line is decoded, since an Identity Center login |
| 140 | * follows it with a plain-text `Profile:` block. |
| 141 | */ |
| 142 | export function kiroAuthFromWhoami( |
| 143 | output: { readonly code: number; readonly stdout: string } | undefined, |
| 144 | environment: NodeJS.ProcessEnv, |
| 145 | ): ServerProviderAuth { |
| 146 | if (output === undefined) return { status: "unknown" }; |
| 147 | if (output.code !== 0) { |
| 148 | return output.stdout.includes('"account":null') |
| 149 | ? { status: "unauthenticated" } |
| 150 | : { status: "unknown" }; |
| 151 | } |
| 152 | const firstLine = output.stdout.trimStart().split("\n", 1)[0] ?? ""; |
| 153 | const account = Option.getOrUndefined(decodeKiroWhoami(firstLine.trim())); |
| 154 | if (account?.accountType === "ApiKey" || environment[KIRO_API_KEY_ENV]?.trim()) { |
| 155 | return { status: "authenticated", type: "api_key", label: "Kiro API key" }; |
| 156 | } |
| 157 | return { |
| 158 | status: "authenticated", |
| 159 | label: "Kiro account", |
| 160 | ...(account?.email ? { email: account.email } : {}), |
| 161 | }; |
| 162 | } |
| 163 | |
| 164 | const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"]; |
| 165 | const CLAUDE_4_6_EFFORT_LEVELS = ["low", "medium", "high", "max"]; |
| 166 | const GPT_5_6_EFFORT_LEVELS = ["none", ...CLAUDE_EFFORT_LEVELS]; |
| 167 | const KIMI_K3_EFFORT_LEVELS = ["low", "high", "max"]; |
| 168 | |
| 169 | /** |
| 170 | * Reasoning levels per Kiro model id and its default level, copied from what |
| 171 | * Kiro 2.32.0 advertises, since `--list-models` names none. Unlisted models take |
| 172 | * no effort; the adapter sends only a level the live session offers. |
| 173 | */ |
| 174 | const KIRO_MODEL_EFFORT: Readonly< |
| 175 | Record<string, { readonly levels: ReadonlyArray<string>; readonly defaultLevel: string }> |
| 176 | > = { |
| 177 | "claude-fable-5.1": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "high" }, |
| 178 | "claude-opus-5.5": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "medium" }, |
| 179 | "claude-opus-5": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "high" }, |
| 180 | "claude-opus-4.8": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "high" }, |
| 181 | "claude-opus-4.7": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "xhigh" }, |
| 182 | "claude-opus-4.6": { levels: CLAUDE_4_6_EFFORT_LEVELS, defaultLevel: "high" }, |
| 183 | "claude-sonnet-5.5": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "high" }, |
| 184 | "claude-sonnet-5": { levels: CLAUDE_EFFORT_LEVELS, defaultLevel: "high" }, |
| 185 | "claude-sonnet-4.6": { levels: CLAUDE_4_6_EFFORT_LEVELS, defaultLevel: "high" }, |
| 186 | "gpt-5.6-sol": { levels: GPT_5_6_EFFORT_LEVELS, defaultLevel: "high" }, |
| 187 | "gpt-5.6-terra": { levels: GPT_5_6_EFFORT_LEVELS, defaultLevel: "high" }, |
| 188 | "gpt-5.6-luna": { levels: GPT_5_6_EFFORT_LEVELS, defaultLevel: "high" }, |
| 189 | "kimi-k3": { levels: KIMI_K3_EFFORT_LEVELS, defaultLevel: "max" }, |
| 190 | }; |
| 191 | const KIRO_EFFORT_LABELS: Readonly<Record<string, string>> = { |
| 192 | none: "None", |
| 193 | low: "Low", |
| 194 | medium: "Medium", |
| 195 | high: "High", |
| 196 | xhigh: "Extra High", |
| 197 | max: "Max", |
| 198 | }; |
| 199 | |
| 200 | function kiroModelCapabilities(modelId: string): ModelCapabilities { |
| 201 | const effort = KIRO_MODEL_EFFORT[modelId]; |
| 202 | if (effort === undefined) return EMPTY_CAPABILITIES; |
| 203 | return createModelCapabilities({ |
| 204 | optionDescriptors: [ |
| 205 | buildSelectOptionDescriptor({ |
| 206 | id: "reasoningEffort", |
| 207 | label: "Reasoning", |
| 208 | options: effort.levels.map((level) => ({ |
| 209 | value: level, |
| 210 | label: KIRO_EFFORT_LABELS[level] ?? level, |
| 211 | isDefault: level === effort.defaultLevel, |
| 212 | })), |
| 213 | }), |
| 214 | ], |
| 215 | }); |
| 216 | } |
| 217 | |
| 218 | const KiroModelList = Schema.fromJsonString( |
| 219 | Schema.Struct({ |
| 220 | models: Schema.Array( |
| 221 | Schema.Struct({ |
| 222 | model_id: Schema.String, |
| 223 | model_name: Schema.optional(Schema.String), |
| 224 | }), |
| 225 | ), |
| 226 | default_model: Schema.optional(Schema.String), |
| 227 | }), |
| 228 | ); |
| 229 | const decodeKiroModelList = Schema.decodeUnknownOption(KiroModelList); |
| 230 | |
| 231 | /** |
| 232 | * Reads `kiro-cli chat --list-models --format json`, the account's models. The |
| 233 | * default entry keeps its name but takes the "default" slug, with Kiro's id as its |
| 234 | * alias. Sessions advertise models only after they start; anything unparsable |
| 235 | * keeps the built-in list. |
| 236 | */ |
| 237 | function kiroModelsFromList( |
| 238 | output: { readonly code: number; readonly stdout: string } | undefined, |
| 239 | ): ReadonlyArray<ServerProviderModel> | undefined { |
| 240 | if (output === undefined || output.code !== 0) return undefined; |
| 241 | const list = Option.getOrUndefined(decodeKiroModelList(output.stdout.trim())); |
| 242 | if (list === undefined || list.models.length === 0) return undefined; |
| 243 | const defaultId = list.default_model ?? KIRO_FALLBACK_DEFAULT_MODEL; |
| 244 | const listedDefault = list.models.find((model) => model.model_id === defaultId); |
| 245 | const defaultModel: ServerProviderModel = { |
| 246 | slug: KIRO_DEFAULT_MODEL_SLUG, |
| 247 | // Named after the model it runs, so a named default isn't hidden behind "Kiro default". |
| 248 | name: listedDefault ? (listedDefault.model_name ?? listedDefault.model_id) : "Kiro default", |
| 249 | aliases: [defaultId], |
| 250 | isCustom: false, |
| 251 | isDefault: true, |
| 252 | // A new session on Kiro's default gets no model write, so Kiro never |
| 253 | // advertises its effort option and a level could not be applied. |
| 254 | capabilities: EMPTY_CAPABILITIES, |
| 255 | }; |
| 256 | const models = list.models.map((model) => |
| 257 | model === listedDefault |
| 258 | ? defaultModel |
| 259 | : { |
| 260 | slug: model.model_id, |
| 261 | name: model.model_name ?? model.model_id, |
| 262 | isCustom: false, |
| 263 | capabilities: kiroModelCapabilities(model.model_id), |
| 264 | }, |
| 265 | ); |
| 266 | // New threads select "default", so it is listed even when Kiro's list leaves its default out. |
| 267 | return models.includes(defaultModel) ? models : [defaultModel, ...models]; |
| 268 | } |
| 269 | |
| 270 | /** |
| 271 | * Kiro's own id for "Kiro default": the alias the model list gave it, else |
| 272 | * `auto`, Kiro's documented default. |
| 273 | */ |
| 274 | export function kiroDefaultModelId(models: ReadonlyArray<ServerProviderModel>): string { |
| 275 | return ( |
| 276 | models.find((model) => model.slug === KIRO_DEFAULT_MODEL_SLUG)?.aliases?.[0] ?? |
| 277 | KIRO_FALLBACK_DEFAULT_MODEL |
| 278 | ); |
| 279 | } |
| 280 | |
| 281 | const KiroConfigTemplate = Schema.Struct({ |
| 282 | configOptions: Schema.Array( |
| 283 | Schema.Struct({ |
| 284 | id: Schema.String, |
| 285 | type: Schema.String, |
| 286 | currentValue: Schema.optional(Schema.Unknown), |
| 287 | options: Schema.optional( |
| 288 | Schema.Array( |
| 289 | Schema.Struct({ |
| 290 | value: Schema.String, |
| 291 | name: Schema.String, |
| 292 | description: Schema.optional(Schema.NullOr(Schema.String)), |
| 293 | }), |
| 294 | ), |
| 295 | ), |
| 296 | }), |
| 297 | ), |
| 298 | }); |
| 299 | const decodeKiroConfigTemplate = Schema.decodeUnknownOption(KiroConfigTemplate); |
| 300 | |
| 301 | /** |
| 302 | * The thread's agent picker, from Kiro's `_kiro/config/template` result, without |
| 303 | * opening a session. The template reads no workspace, so a project's |
| 304 | * `.kiro/agents` are not offered. |
| 305 | */ |
| 306 | export function kiroAgentDescriptor(template: unknown): ProviderOptionDescriptor | undefined { |
| 307 | const decoded = Option.getOrUndefined(decodeKiroConfigTemplate(template)); |
| 308 | const mode = decoded?.configOptions.find( |
| 309 | (option) => option.id === KIRO_AGENT_CONFIG_ID && option.type === "select", |
| 310 | ); |
| 311 | const defaultAgent = typeof mode?.currentValue === "string" ? mode.currentValue : undefined; |
| 312 | const choices = (mode?.options ?? []).flatMap((choice) => { |
| 313 | const id = choice.value.trim(); |
| 314 | const label = choice.name.trim() || id; |
| 315 | const description = choice.description?.trim(); |
| 316 | return id.length === 0 |
| 317 | ? [] |
| 318 | : [ |
| 319 | { |
| 320 | id, |
| 321 | label, |
| 322 | ...(description ? { description } : {}), |
| 323 | ...(id === defaultAgent ? { isDefault: true } : {}), |
| 324 | }, |
| 325 | ]; |
| 326 | }); |
| 327 | // One agent is nothing to choose between. |
| 328 | if (choices.length < 2) return undefined; |
| 329 | return { |
| 330 | id: KIRO_AGENT_CONFIG_ID, |
| 331 | label: "Agent", |
| 332 | type: "select", |
| 333 | options: choices, |
| 334 | ...(defaultAgent !== undefined && choices.some((choice) => choice.isDefault) |
| 335 | ? { currentValue: defaultAgent } |
| 336 | : {}), |
| 337 | }; |
| 338 | } |
| 339 | |
| 340 | /** |
| 341 | * Asks Kiro for its agents with `initialize` and `_kiro/config/template` and |
| 342 | * nothing more: no `session/new`, so no MCP server starts and no session is |
| 343 | * stored. The process runs in the server's working directory. |
| 344 | */ |
| 345 | const probeKiroAgents = Effect.fn("KiroProvider.probeKiroAgents")(function* ( |
| 346 | settings: KiroSettings, |
| 347 | environment: NodeJS.ProcessEnv, |
| 348 | ) { |
| 349 | const runtime = yield* makeKiroAcpRuntime({ |
| 350 | settings, |
| 351 | environment, |
| 352 | cwd: yield* HostProcess.WorkingDirectory, |
| 353 | clientInfo: { name: "t3-code-provider-probe", version: "0.0.0" }, |
| 354 | }); |
| 355 | yield* runtime.initialize(); |
| 356 | return kiroAgentDescriptor(yield* runtime.request("_kiro/config/template", {})); |
| 357 | }, Effect.scoped); |
| 358 | |
| 359 | export const checkKiroProviderStatus = Effect.fn("checkKiroProviderStatus")(function* ( |
| 360 | settings: KiroSettings, |
| 361 | environment: NodeJS.ProcessEnv, |
| 362 | ): Effect.fn.Return< |
| 363 | ServerProviderDraft, |
| 364 | never, |
| 365 | ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom |
| 366 | > { |
| 367 | const checkedAt = DateTime.formatIso(yield* DateTime.now); |
| 368 | if (!settings.enabled) { |
| 369 | return snapshot(settings, checkedAt, { |
| 370 | installed: false, |
| 371 | version: null, |
| 372 | status: "warning", |
| 373 | auth: { status: "unknown" }, |
| 374 | message: "Kiro is disabled in T3 Code settings.", |
| 375 | }); |
| 376 | } |
| 377 | |
| 378 | const probeEnvironment = providerProbeEnvironment(environment); |
| 379 | const versionResult = yield* runKiroCli(settings, ["--version"], probeEnvironment).pipe( |
| 380 | Effect.timeoutOption( |
| 381 | resolveProviderProbeTimeoutMs("kiro", VERSION_PROBE_TIMEOUT_MS, environment), |
| 382 | ), |
| 383 | Effect.result, |
| 384 | ); |
| 385 | if (Result.isFailure(versionResult) || Option.isNone(versionResult.success)) { |
| 386 | const missing = Result.isFailure(versionResult) && isCommandMissingCause(versionResult.failure); |
| 387 | return snapshot(settings, checkedAt, { |
| 388 | installed: !missing, |
| 389 | version: null, |
| 390 | status: "error", |
| 391 | auth: { status: "unknown" }, |
| 392 | message: missing |
| 393 | ? "Kiro CLI (`kiro-cli`) is not installed or not on PATH." |
| 394 | : "Failed to run `kiro-cli --version`.", |
| 395 | }); |
| 396 | } |
| 397 | const versionOutput = versionResult.success.value; |
| 398 | const version = parseCliVersionResult(versionOutput); |
| 399 | if (versionOutput.code !== 0) { |
| 400 | return snapshot(settings, checkedAt, { |
| 401 | installed: true, |
| 402 | version, |
| 403 | status: "error", |
| 404 | auth: { status: "unknown" }, |
| 405 | message: "Kiro CLI is installed but failed to run.", |
| 406 | }); |
| 407 | } |
| 408 | |
| 409 | const whoamiResult = yield* runKiroCli( |
| 410 | settings, |
| 411 | ["whoami", "--format", "json"], |
| 412 | probeEnvironment, |
| 413 | ).pipe( |
| 414 | Effect.timeoutOption(resolveProviderProbeTimeoutMs("kiro", AUTH_PROBE_TIMEOUT_MS, environment)), |
| 415 | Effect.result, |
| 416 | ); |
| 417 | const auth = kiroAuthFromWhoami( |
| 418 | Result.isSuccess(whoamiResult) ? Option.getOrUndefined(whoamiResult.success) : undefined, |
| 419 | environment, |
| 420 | ); |
| 421 | if (auth.status === "unauthenticated") { |
| 422 | return snapshot(settings, checkedAt, { |
| 423 | installed: true, |
| 424 | version, |
| 425 | status: "error", |
| 426 | auth, |
| 427 | message: "Kiro CLI is installed but not signed in. Run `kiro-cli login`.", |
| 428 | }); |
| 429 | } |
| 430 | // Signed out, `--list-models` starts a browser login instead, and the agent |
| 431 | // probe fails to start, so both run only once `whoami` has confirmed the |
| 432 | // account. Without an agent list the composer shows no agent picker. |
| 433 | const [listed, agents] = |
| 434 | auth.status === "authenticated" |
| 435 | ? yield* Effect.all( |
| 436 | [ |
| 437 | runKiroCli( |
| 438 | settings, |
| 439 | ["chat", "--list-models", "--format", "json"], |
| 440 | probeEnvironment, |
| 441 | ).pipe( |
| 442 | Effect.timeoutOption( |
| 443 | resolveProviderProbeTimeoutMs("kiro", AUTH_PROBE_TIMEOUT_MS, environment), |
| 444 | ), |
| 445 | Effect.map((output) => kiroModelsFromList(Option.getOrUndefined(output))), |
| 446 | Effect.orElseSucceed(() => undefined), |
| 447 | ), |
| 448 | probeKiroAgents(settings, probeEnvironment).pipe( |
| 449 | Effect.timeoutOption( |
| 450 | resolveProviderProbeTimeoutMs("kiro", AUTH_PROBE_TIMEOUT_MS, environment), |
| 451 | ), |
| 452 | Effect.map(Option.getOrUndefined), |
| 453 | Effect.orElseSucceed(() => undefined), |
| 454 | ), |
| 455 | ], |
| 456 | { concurrency: "unbounded" }, |
| 457 | ) |
| 458 | : [undefined, undefined]; |
| 459 | return snapshot( |
| 460 | settings, |
| 461 | checkedAt, |
| 462 | { |
| 463 | installed: true, |
| 464 | version, |
| 465 | status: auth.status === "authenticated" ? "ready" : "warning", |
| 466 | auth, |
| 467 | ...(auth.status === "authenticated" |
| 468 | ? {} |
| 469 | : { message: "Could not confirm the Kiro sign-in. Run `kiro-cli whoami` to check." }), |
| 470 | }, |
| 471 | listed, |
| 472 | agents, |
| 473 | ); |
| 474 | }); |