@agent-relay/sdk 7.1.1 → 8.0.2

package/README.md

@@ -1,215 +1,249 @@
 # @agent-relay/sdk
 
-TypeScript SDK for building multi-agent workflows with Agent Relay. Provides both low-level broker control and high-level workflow orchestration.
+Core TypeScript SDK for Agent Relay communication. The SDK gives agents and applications three public capabilities: messaging, delivery, and actions.
+
+Use `@agent-relay/sdk` when your app, service, harness, or worker already owns its runtime and needs to participate in Agent Relay. Use `@agent-relay/harness-driver` when you want Agent Relay to start and supervise Claude, Codex, Gemini, OpenCode, or other local harness processes.
 
 ## Installation
 
 ```bash
-npm install @agent-relay/sdk
+npm install @agent-relay/sdk zod
 ```
 
-## Quick Start
+## Concepts
 
-### Workflow Builder (Recommended)
+- **Messaging** is durable agent communication: identities, channels, DMs, group DMs, threads, reactions, inbox, read state, presence, search, and events.
+- **Delivery** is runtime handoff: taking durable messages from Agent Relay and injecting them into a live agent process, service, app server, browser worker, or harness.
+- **Actions** are typed capabilities: discoverable operations with Zod schemas, policy hooks, audit events, and structured result/error envelopes.
+- **Runtime** is optional managed execution. Daemon startup, PTY/headless sessions, spawn/release, harness defaults, logs, readiness, and workflow supervision belong in `@agent-relay/harness-driver`.
 
-The workflow builder is the primary way to define and run multi-agent workflows:
+## Quick start
 
 ```ts
-import { workflow } from '@agent-relay/sdk/workflows';
-
-const result = await workflow('my-feature')
-  .pattern('dag')
-  .agent('planner', { cli: 'claude', role: 'Planning lead' })
-  .agent('builder', { cli: 'codex', role: 'Implementation engineer' })
-  .step('plan', { agent: 'planner', task: 'Create a detailed plan' })
-  .step('build', { agent: 'builder', task: 'Implement the plan', dependsOn: ['plan'] })
-  .run();
-```
-
-### High-Level Facade
+import { AgentRelay } from '@agent-relay/sdk';
 
-The `AgentRelay` class provides a clean API for spawning and managing agents:
+const relay = new AgentRelay({
+  workspaceKey: process.env.RELAY_WORKSPACE_KEY!,
+});
 
-```ts
-import { AgentRelay } from '@agent-relay/sdk';
+const reviewer = await relay.agents.register({ name: 'reviewer' });
+const agent = relay.as(reviewer);
 
-const relay = new AgentRelay();
+await agent.channels.join('reviews');
 
-// Event hooks
-relay.onMessageReceived = (msg) => console.log(`${msg.from}: ${msg.text}`);
-relay.onAgentIdle = ({ name, idleSecs }) => console.log(`${name} idle for ${idleSecs}s`);
-relay.onAgentActivityChanged = ({ name, active, pendingDeliveries }) => {
-  updateThinkingBadge(name, active ? `Thinking (${pendingDeliveries})` : 'Idle');
-};
+agent.events.on('message.created', async (event) => {
+  if (event.channel !== 'reviews') return;
 
-// Spawn agents using shorthand spawners
-const worker = await relay.claude.spawn({
-  name: 'Worker1',
-  channels: ['general'],
-  // Lifecycle hooks can be sync or async functions.
-  onStart: ({ name }) => console.log(`spawning ${name}`),
-  onSuccess: ({ name, runtime }) => console.log(`spawned ${name} (${runtime})`),
-  onError: ({ name, error }) => console.error(`failed to spawn ${name}`, error),
+  await agent.messages.reply({
+    messageId: event.message.id,
+    text: 'Received. I will review this thread.',
+  });
+  await agent.messages.markRead(event.message.id);
 });
 
-// Or use the generic spawn method
-const agent = await relay.spawn('Worker2', 'codex', 'Build the API', {
-  channels: ['dev'],
-  model: 'gpt-4o',
+await agent.messages.send({
+  channel: 'reviews',
+  text: 'Reviewer is online.',
 });
+```
 
-// Wait for agent to finish (go idle or exit)
-const result = await agent.waitForIdle(120_000);
+You can also create a new workspace directly:
 
-// Release with lifecycle hooks
-await worker.release({
-  reason: 'done',
-  onStart: ({ name }) => console.log(`releasing ${name}`),
-  onSuccess: ({ name }) => console.log(`released ${name}`),
+```ts
+const relay = await AgentRelay.createWorkspace({
+  name: 'review-workspace',
 });
+```
 
-// Send messages
-const human = relay.human({ name: 'Orchestrator' });
-await human.sendMessage({ to: 'Worker1', text: 'Start the task' });
+## Messaging
 
-// Clean up
-await relay.shutdown();
-```
+The core client covers the communication surface agents need during a run:
 
-### Low-Level Client
+- Register agent, human, and system identities.
+- Join, list, create, update, mute, archive, and inspect channels.
+- Send channel messages, direct messages, and group DMs.
+- Reply in threads and fetch message history.
+- Add and remove reactions.
+- Search messages and inspect inbox state.
+- Subscribe to events for messages, threads, DMs, reactions, channel changes, presence, files, webhooks, and action invocations.
 
-For direct broker control:
+Example:
 
 ```ts
-import { AgentRelayClient } from '@agent-relay/sdk';
+const lead = relay.as(await relay.agents.register({ name: 'lead' }));
 
-// Spawn a local broker and connect over HTTP/WS
-const client = await AgentRelayClient.spawn({
-  cwd: '/my/project',
-  channels: ['general'],
+await lead.channels.create({
+  name: 'release',
+  topic: 'Release readiness',
 });
 
-const unsubscribeBrokerExit = client.onBrokerExit((info) => {
-  console.error('broker exited', info.code, info.signal, info.recentStderr);
-  unsubscribeBrokerExit();
+await lead.messages.send({
+  channel: 'release',
+  text: 'Please review the migration guide.',
 });
 
-// Or connect to an already-running broker (reads connection.json)
-// const client = AgentRelayClient.connect({ cwd: '/my/project' });
-
-// Or connect to a remote broker directly
-// const client = new AgentRelayClient({ baseUrl: 'http://...', apiKey: 'br_...' });
-
-await client.spawnPty({
-  name: 'Worker1',
-  cli: 'claude',
-  channels: ['general'],
-  task: 'Implement user authentication',
+const thread = await lead.messages.reply({
+  messageId: 'msg_123',
+  text: 'Tracking docs feedback here.',
 });
 
-const agents = await client.listAgents();
-await client.release('Worker1');
-await client.shutdown();
+await lead.messages.react({
+  messageId: thread.id,
+  emoji: 'eyes',
+});
 ```
 
-### Provider + Transport Spawning (Opencode/Claude)
+## Delivery
 
-Use provider-first spawn helpers and set `transport` when you want headless mode.
+Delivery is the session handoff contract. Relay stores messages durably; a session is the thing that can receive those messages inside an agent, service, browser worker, or managed harness:
 
-```ts
-import { AgentRelayClient } from '@agent-relay/sdk';
+- Harnesses create sessions with stable agent identity.
+- Sessions declare capabilities such as delivery modes, observable events, actions, and lifecycle operations.
+- Sessions receive durable Relay messages with delivery context and return explicit receipts: `accepted`, `delivered`, `deferred`, or `failed`.
+- `DeliveryRunner` can drain inbox items into either a session `receiveMessage(...)` contract or a legacy `inject(...)` adapter.
+- Send operations support idempotency keys so retries do not duplicate messages.
 
-const client = await AgentRelayClient.spawn({
-  channels: ['general'],
-});
+Managed harness delivery, such as injecting messages into a PTY or headless app server, belongs in `@agent-relay/harness-driver`. The SDK stays responsible for the public delivery contract.
 
-await client.spawnOpencode({
-  name: 'OpencodeWorker',
-  transport: 'headless',
-  channels: ['general'],
-  task: 'Review this PR and report risks',
-});
+Minimum session contract:
 
-await client.spawnClaude({
-  name: 'ClaudeHeadless',
-  transport: 'headless', // override default PTY transport
-  channels: ['general'],
-  task: 'Summarize release risks',
-});
-
-// ... interact with the worker via sendMessage/listAgents/events ...
+```ts
+import {
+  DeliveryRunner,
+  MINIMAL_AGENT_SESSION_CAPABILITIES,
+  normalizeAgentIdentity,
+  type AgentSession,
+} from '@agent-relay/sdk';
+
+const session: AgentSession = {
+  identity: normalizeAgentIdentity({ id: 'agent_reviewer', name: 'reviewer', handle: '@reviewer' }),
+  capabilities: {
+    ...MINIMAL_AGENT_SESSION_CAPABILITIES,
+    delivery: { modes: ['immediate', 'next-tool-call', 'on-idle'], queue: true },
+    events: { emits: ['status.changed', 'tool.called', 'tool.completed', 'file.changed'] },
+    actions: { invoke: true, expose: false },
+  },
+  async receiveMessage(message, context) {
+    const job = await service.enqueue({
+      id: message.id,
+      text: message.text,
+      threadId: message.threadId,
+      priority: context.priority ?? 'normal',
+      deliveryMode: context.mode,
+    });
+
+    return job.ready
+      ? { status: 'delivered', deliveryId: job.id }
+      : { status: 'deferred', deliveryId: job.id, availableAt: job.availableAt };
+  },
+  onEvent(emit) {
+    return service.onStatus((status) => emit({ type: 'status.changed', status }));
+  },
+  async release(reason) {
+    await service.release(reason);
+  },
+};
 
-await client.shutdown();
+await new DeliveryRunner({
+  messaging: relay.as(reviewer).messaging,
+  delivery: session,
+  agentName: 'reviewer',
+}).start();
 ```
 
-Notes:
+## Actions
 
-- Transport is a setting (`'pty'` or `'headless'`) on provider spawn methods.
-- `spawnClaude(...)` defaults to PTY unless you pass `transport: 'headless'`.
-- `spawnOpencode(...)` defaults to headless.
-- You can also use `client.spawnProvider({ provider, transport, ... })` for generic provider-driven spawning.
+Agent Relay actions are exposed through registration and invocation:
 
-## Features
+- Register actions with names, descriptions, and Zod input/output schemas.
+- Validate inputs before handlers run and validate outputs before callers receive them.
+- Attach policy hooks for allow/deny decisions.
+- Emit audit events for invoked, completed, failed, and denied actions.
+- Expose registered actions as MCP tools for agents that do not embed the SDK.
 
-- **Workflow Builder** — Fluent API for defining DAG-based multi-agent workflows
-- **Agent Spawning** — Spawn Claude, Codex, Gemini, Aider, or Goose agents
-- **Idle Detection** — Configurable silence threshold with `onAgentIdle` hook and `waitForIdle()`
-- **Message Delivery** — Track message delivery states (queued, injected, active, verified)
-- **Event Streaming** — Real-time events for agent lifecycle, output, and messaging
-- **Shadow Agents** — Spawn observer agents that monitor other agents
-- **Consensus** — Multi-agent voting and consensus helpers
+This keeps action routing available to any runtime without requiring a local broker or spawned harness.
 
-## Subpath Exports
+Example:
 
 ```ts
-import { AgentRelayClient } from '@agent-relay/sdk/client';
-import { workflow, WorkflowBuilder } from '@agent-relay/sdk/workflows';
-import { ConsensusCoordinator } from '@agent-relay/sdk/consensus';
-import { ShadowCoordinator } from '@agent-relay/sdk/shadow';
-```
-
-## Workflow Templates
+import { z } from 'zod';
 
-Built-in templates for common patterns:
+const OpenPullRequestInput = z.object({
+  repository: z.string(),
+  branch: z.string(),
+  title: z.string(),
+  body: z.string().optional(),
+});
 
-```ts
-import { fanOut, pipeline, dag } from '@agent-relay/sdk/workflows';
+const OpenPullRequestOutput = z.object({
+  url: z.string().url(),
+  number: z.number().int().positive(),
+});
 
-// Fan-out: parallel execution with synthesis
-const builder = fanOut('analysis', {
-  tasks: ['Analyze backend', 'Analyze frontend'],
-  synthesisTask: 'Combine analyses into action plan',
+relay.actions.register({
+  name: 'github.open_pr',
+  description: 'Open a GitHub pull request for a prepared branch.',
+  inputSchema: OpenPullRequestInput,
+  outputSchema: OpenPullRequestOutput,
+  policy: async (_input, ctx) => ({
+    allowed: ctx.caller.type === 'agent' && ctx.caller.name.startsWith('release-'),
+    reason: 'Only release agents can open PRs',
+  }),
+  handler: async (input, ctx) => {
+    const pr = await github.openPullRequest(input);
+    await ctx.messaging?.messages.direct({
+      to: ctx.caller.name,
+      text: `Opened ${pr.url}`,
+    });
+    return { url: pr.url, number: pr.number };
+  },
 });
 
-// Pipeline: sequential stages
-const builder = pipeline('release', {
-  stages: [
-    { name: 'plan', task: 'Create release plan' },
-    { name: 'implement', task: 'Implement changes' },
-    { name: 'verify', task: 'Run verification' },
-  ],
+const pr = await relay.actions.invoke({
+  name: 'github.open_pr',
+  input: {
+    repository: 'AgentWorkforce/relay',
+    branch: 'codex/core-simplification',
+    title: 'Simplify Agent Relay core surfaces',
+  },
+  caller: { name: 'release-lead', type: 'agent' },
 });
 ```
 
-## Relaycast Integration
+## Optional managed harnesses
 
-The SDK re-exports Relaycast client types for cloud-based relay coordination:
+Install the harness driver package for managed local execution:
 
-```ts
-import { RelayCast, AgentClient } from '@agent-relay/sdk';
+```bash
+npm install @agent-relay/harness-driver
 ```
 
+`@agent-relay/harness-driver` owns:
+
+- Local broker process startup and connection files.
+- PTY and headless harness transports.
+- Claude, Codex, Gemini, OpenCode, and custom CLI spawn defaults.
+- Agent lifecycle hooks, session metadata, idle detection, managed release, and shutdown.
+- Workflow and supervision helpers that coordinate multiple spawned harnesses.
+
+Keep application-level messaging code on `@agent-relay/sdk`; add `@agent-relay/harness-driver` only at the boundary that owns local agent processes.
+
+## Migration from the pre-simplification SDK
+
+| Previous SDK surface                                                                               | SemVer-major target                                                    |
+| -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| Spawn methods on `AgentRelay`, `HarnessDriverClient.spawn()`, `spawnAgent()`, PTY/headless helpers | Move to `@agent-relay/harness-driver`.                                 |
+| Workflow builder, consensus, shadow agents, and managed run helpers                                | Move to `@agent-relay/harness-driver` or workflow-specific packages.   |
+| Messaging, identities, channels, DMs, threads, presence, read state, and actions                   | Stay in `@agent-relay/sdk`.                                            |
+| Primitive clients such as GitHub or Slack adapters                                                 | Stay in their own packages and integrate through SDK actions/messages. |
+
+Code that only sends and receives Agent Relay messages should keep depending on `@agent-relay/sdk`. Code that starts agents, injects messages into harnesses, or supervises local runs should add `@agent-relay/harness-driver`.
+
 ## Development
 
 ```bash
-# Build
 npm --prefix packages/sdk run build
-
-# Run tests
 npm --prefix packages/sdk test
-
-# Run demo
-npm --prefix packages/sdk run demo
 ```
 
 ## License

package/dist/actions/errors.d.ts

@@ -0,0 +1,18 @@
+import type { ActionValidationIssue } from './types.js';
+export declare class ActionRegistrationError extends Error {
+    readonly code = "action_registration_error";
+    constructor(message: string);
+}
+export declare class ActionNotFoundError extends Error {
+    readonly code = "action_not_found";
+    readonly action: string;
+    constructor(action: string);
+}
+export declare class ActionValidationError extends Error {
+    readonly code = "action_validation_error";
+    readonly action: string;
+    readonly phase: 'input' | 'output';
+    readonly issues: ActionValidationIssue[];
+    constructor(action: string, phase: 'input' | 'output', issues: ActionValidationIssue[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/actions/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/actions/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,+BAA+B;gBAEhC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,sBAAsB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAK3B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,6BAA6B;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,EAAE,CAAC;gBAE7B,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,QAAQ,EAAE,MAAM,EAAE,qBAAqB,EAAE;CAOvF"}

package/dist/actions/errors.js

@@ -0,0 +1,39 @@
+export class ActionRegistrationError extends Error {
+    code = 'action_registration_error';
+    constructor(message) {
+        super(message);
+        this.name = 'ActionRegistrationError';
+    }
+}
+export class ActionNotFoundError extends Error {
+    code = 'action_not_found';
+    action;
+    constructor(action) {
+        super(`No action registered for '${action}'`);
+        this.name = 'ActionNotFoundError';
+        this.action = action;
+    }
+}
+export class ActionValidationError extends Error {
+    code = 'action_validation_error';
+    action;
+    phase;
+    issues;
+    constructor(action, phase, issues) {
+        super(formatValidationMessage(action, phase, issues));
+        this.name = 'ActionValidationError';
+        this.action = action;
+        this.phase = phase;
+        this.issues = issues;
+    }
+}
+function formatValidationMessage(action, phase, issues) {
+    const suffix = issues
+        .slice(0, 3)
+        .map((issue) => `${issue.path}: ${issue.message}`)
+        .join('; ');
+    return suffix
+        ? `Action '${action}' ${phase} failed validation: ${suffix}`
+        : `Action '${action}' ${phase} failed validation`;
+}
+//# sourceMappingURL=errors.js.map

package/dist/actions/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/actions/errors.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IACvC,IAAI,GAAG,2BAA2B,CAAC;IAE5C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnC,IAAI,GAAG,kBAAkB,CAAC;IAC1B,MAAM,CAAS;IAExB,YAAY,MAAc;QACxB,KAAK,CAAC,6BAA6B,MAAM,GAAG,CAAC,CAAC;QAC9C,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAED,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IACrC,IAAI,GAAG,yBAAyB,CAAC;IACjC,MAAM,CAAS;IACf,KAAK,CAAqB;IAC1B,MAAM,CAA0B;IAEzC,YAAY,MAAc,EAAE,KAAyB,EAAE,MAA+B;QACpF,KAAK,CAAC,uBAAuB,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAED,SAAS,uBAAuB,CAC9B,MAAc,EACd,KAAyB,EACzB,MAA+B;IAE/B,MAAM,MAAM,GAAG,MAAM;SAClB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;SACX,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;SACjD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO,MAAM;QACX,CAAC,CAAC,WAAW,MAAM,KAAK,KAAK,uBAAuB,MAAM,EAAE;QAC5D,CAAC,CAAC,WAAW,MAAM,KAAK,KAAK,oBAAoB,CAAC;AACtD,CAAC"}

package/dist/actions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './errors.js';
+export * from './json-schema-lite.js';
+export * from './registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}

package/dist/actions/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './errors.js';
+export * from './json-schema-lite.js';
+export * from './registry.js';
+//# sourceMappingURL=index.js.map

package/dist/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}

package/dist/actions/json-schema-lite.d.ts

@@ -0,0 +1,13 @@
+import type { ActionSchema, ActionValidationResult, JsonSchemaLite } from './types.js';
+export declare function validateJsonSchemaLite(value: unknown, schema: JsonSchemaLite | undefined): ActionValidationResult;
+/**
+ * Coerce an {@link ActionSchema} into a plain JSON Schema object suitable for
+ * sending to the relay as an action descriptor's `input_schema`/`output_schema`.
+ *
+ * - A JSON-schema-lite object (the relay's native shape) is returned as-is.
+ * - A standard-schema validator (e.g. `zod`) is converted via its JSON Schema
+ *   bridge when one is available, falling back to a permissive object schema.
+ * - `undefined` yields `undefined` (the descriptor omits the schema).
+ */
+export declare function actionSchemaToJsonSchema(schema: ActionSchema | undefined): Record<string, unknown> | undefined;
+//# sourceMappingURL=json-schema-lite.d.ts.map

package/dist/actions/json-schema-lite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-lite.d.ts","sourceRoot":"","sources":["../../src/actions/json-schema-lite.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,YAAY,EAEZ,sBAAsB,EACtB,cAAc,EAIf,MAAM,YAAY,CAAC;AAMpB,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,cAAc,GAAG,SAAS,GACjC,sBAAsB,CAQxB;AAsTD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAiBrC"}