@flow-a2a/shared 0.1.2 → 0.1.3

package/README.md

@@ -0,0 +1,40 @@
+# @flow-a2a/shared
+
+Shared type package for the flow-a2a protocol stack.
+
+Used by [`@flow-a2a/plugin`](https://www.npmjs.com/package/@flow-a2a/plugin) and the Lattice API center to guarantee that wire-format types stay in sync. See the [flow-a2a README](https://github.com/FlowGPT/lattice/tree/main/packages/flow-a2a) for the full stack overview.
+
+## Contents
+
+- **`types.ts`** — WebSocket message types (`ClientMessage` / `ServerMessage`), lobster identity, Feishu mention shape
+- **`pricing.ts`** — per-1M-token pricing for mainstream models (Claude / GPT / DeepSeek / Gemini, etc.), consumed by the cost tracker
+
+## Install
+
+```sh
+npm install @flow-a2a/shared
+# or
+bun add @flow-a2a/shared
+```
+
+## Usage
+
+```ts
+import type { ClientMessage, ServerMessage, LobsterIdentity } from '@flow-a2a/shared'
+import { getPricing } from '@flow-a2a/shared'
+
+const pricing = getPricing('claude-opus-4-6')
+// { input: 15, output: 75, cacheRead: 0, cacheWrite: 0 } per 1M tokens
+```
+
+## Versioning
+
+**The protocol is the contract between plugin and center.** Whenever you change `types.ts`:
+
+1. Bump `shared/` — patch for backward-compatible fields, minor/major for breaking changes
+2. Update `plugin/` and `apps/api/src/center/` implementations
+3. Release `shared` and `plugin` together
+
+## License
+
+MIT

package/dist/a2a-types.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Lattice A2A Protocol · v1 · Type Definitions
+ *
+ * Source of truth: .claude/a2a-protocol.md + .claude/a2a-spec.md
+ *
+ * All WS frames = JSON-RPC 2.0 Notification:
+ *   { jsonrpc: "2.0", method: <frame-name>, params: {...} }
+ *
+ * `params.taskId` correlates multi-frame exchanges (not JSON-RPC id/result).
+ */
+export interface JsonRpcNotification<M extends string = string, P = unknown> {
+    jsonrpc: "2.0";
+    method: M;
+    params: P;
+}
+export type TaskState = "submitted" | "working" | "input-required" | "auth-required" | "completed" | "failed" | "canceled" | "rejected";
+export declare const TERMINAL_STATES: ReadonlySet<TaskState>;
+/** Legal state transitions (a2a-spec.md §2.7 / a2a-protocol.md §4.3). */
+export declare const LEGAL_STATE_TRANSITIONS: ReadonlyMap<TaskState, ReadonlySet<TaskState>>;
+export declare function isTerminal(state: TaskState): boolean;
+export declare function isLegalTransition(from: TaskState, to: TaskState): boolean;
+export interface TextPart {
+    kind: "text";
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FilePart {
+    kind: "file";
+    file: {
+        uri: string;
+        mimeType?: string;
+        name?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface DataPart {
+    kind: "data";
+    data: unknown;
+    metadata?: Record<string, unknown>;
+}
+/** Lattice extension: reference an artifact produced by another task in the same context. */
+export interface ArtifactRefPart {
+    kind: "artifact-ref";
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    metadata?: Record<string, unknown>;
+}
+export type Part = TextPart | FilePart | DataPart | ArtifactRefPart;
+export interface Message {
+    kind: "message";
+    messageId: string;
+    role: "user" | "agent";
+    parts: Part[];
+    metadata?: Record<string, unknown>;
+}
+export interface Artifact {
+    artifactId: string;
+    name: string;
+    description?: string;
+    parts: Part[];
+    metadata?: Record<string, unknown>;
+}
+export interface TaskStatus {
+    state: TaskState;
+    message?: Message;
+    /** Optional structured error payload — populated when `state` is `failed` /
+     *  `rejected` / `canceled` with a reason. Mirrors `a2a.error` params code+message. */
+    error?: {
+        code: number;
+        message: string;
+    };
+    timestamp: string;
+}
+export interface TaskMetadata {
+    "lattice.fromAgent"?: string;
+    "lattice.toAgent"?: string;
+    "lattice.skillId"?: string;
+    "lattice.parentTaskId"?: string | null;
+    "lattice.rootTaskId"?: string;
+    "lattice.triggeredBy"?: "agent" | "user" | "system";
+    "lattice.triggeredByUserId"?: string;
+    "lattice.costUsd"?: number;
+    "lattice.durationMs"?: number;
+    [k: string]: unknown;
+}
+export interface Task {
+    id: string;
+    contextId: string;
+    kind: "task";
+    status: TaskStatus;
+    artifacts: Artifact[];
+    history?: Message[];
+    metadata: TaskMetadata;
+}
+export interface Context {
+    id: string;
+    title?: string;
+    rootTaskId: string;
+    createdByAgent: string;
+    triggeredByUserId?: string | null;
+    createdAt: string;
+    closedAt?: string | null;
+    memberAgents: string[];
+}
+export interface SkillDef {
+    id: string;
+    name: string;
+    description: string;
+    tags?: string[];
+    examples?: string[];
+}
+export interface AgentCardCapabilities {
+    streaming: boolean;
+    stateTransitionHistory?: boolean;
+}
+/** Lattice overlay — written by center, never by agent. */
+export interface AgentCardLatticeOverlay {
+    team?: string;
+    owner?: string;
+    lifecycle?: "active" | "retired";
+    rateLimit?: {
+        rps?: number;
+        concurrency?: number;
+    };
+    costHintUsd?: number;
+}
+export interface AgentCard {
+    name: string;
+    description: string;
+    version: string;
+    url?: string;
+    capabilities: AgentCardCapabilities;
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    skills: SkillDef[];
+    lattice?: AgentCardLatticeOverlay;
+}
+export interface DirectoryAgentEntry {
+    agentId: string;
+    online: boolean;
+    lifecycle: "active" | "retired";
+    skills: string[];
+}
+export interface DirectorySnapshot {
+    version: number;
+    agents: DirectoryAgentEntry[];
+}
+export interface RegisterParams {
+    agentId: string;
+    token?: string;
+    meta?: {
+        agentId?: string;
+        instanceId?: string;
+        [k: string]: unknown;
+    };
+}
+export type RegisterFrame = JsonRpcNotification<"register", RegisterParams>;
+export interface RegisteredParams {
+    sessionId: string;
+    directorySnapshot: DirectorySnapshot;
+}
+export type RegisteredFrame = JsonRpcNotification<"registered", RegisteredParams>;
+export interface PingParams {
+    ts: number;
+}
+export type PingFrame = JsonRpcNotification<"ping", PingParams>;
+export interface PongParams {
+    ts: number;
+}
+export type PongFrame = JsonRpcNotification<"pong", PongParams>;
+export interface A2ACallParams {
+    taskId: string;
+    to: string;
+    message: Message;
+    parentTaskId?: string | null;
+    contextId?: string | null;
+    skillId?: string;
+    metadata?: Record<string, unknown>;
+    ts: number;
+}
+export type A2ACallFrame = JsonRpcNotification<"a2a.call", A2ACallParams>;
+export interface A2ACallAckParams {
+    taskId: string;
+    to: string;
+    status: "accepted" | "rejected";
+    reason?: string;
+    ts: number;
+}
+export type A2ACallAckFrame = JsonRpcNotification<"a2a.call.ack", A2ACallAckParams>;
+export interface A2AProgressParams {
+    taskId: string;
+    to: string;
+    message: Message;
+    ts: number;
+}
+export type A2AProgressFrame = JsonRpcNotification<"a2a.progress", A2AProgressParams>;
+export interface A2AResultParams {
+    taskId: string;
+    to: string;
+    status: TaskStatus;
+    artifacts?: Artifact[];
+    metadata?: Record<string, unknown>;
+    ts: number;
+}
+export type A2AResultFrame = JsonRpcNotification<"a2a.result", A2AResultParams>;
+export interface A2ACancelParams {
+    taskId: string;
+    to: string;
+    reason?: string;
+    ts: number;
+}
+export type A2ACancelFrame = JsonRpcNotification<"a2a.cancel", A2ACancelParams>;
+export interface A2AErrorParams {
+    taskId?: string;
+    code: number;
+    message: string;
+    data?: Record<string, unknown>;
+    ts: number;
+}
+export type A2AErrorFrame = JsonRpcNotification<"a2a.error", A2AErrorParams>;
+export interface A2ASkillUpdatedParams {
+    agentId: string;
+    online: boolean;
+    lifecycle: "active" | "retired";
+    diff: {
+        added: string[];
+        removed: string[];
+        changed: string[];
+    };
+    directoryVersion: number;
+    ts: number;
+}
+export type A2ASkillUpdatedFrame = JsonRpcNotification<"a2a.skill.updated", A2ASkillUpdatedParams>;
+export interface A2AAgentRetiredParams {
+    agentId: string;
+    directoryVersion: number;
+    ts: number;
+}
+export type A2AAgentRetiredFrame = JsonRpcNotification<"a2a.agent.retired", A2AAgentRetiredParams>;
+export interface A2AEdgeRevokedParams {
+    fromAgent: string;
+    toAgent: string;
+    directoryVersion: number;
+    ts: number;
+}
+export type A2AEdgeRevokedFrame = JsonRpcNotification<"a2a.edge.revoked", A2AEdgeRevokedParams>;
+export type ContextEventKind = "task.created" | "task.progress" | "task.completed" | "task.failed" | "task.canceled" | "context.closed";
+export interface A2AContextEventParams {
+    contextId: string;
+    taskId: string;
+    ownerAgent: string;
+    kind: ContextEventKind;
+    summaryText?: string;
+    artifactsAdded?: Array<{
+        artifactId: string;
+        name: string;
+        mimeType?: string;
+    }>;
+    ts: number;
+}
+export type A2AContextEventFrame = JsonRpcNotification<"a2a.context.event", A2AContextEventParams>;
+export interface A2APolicyUpdatedParams {
+    policyVersion: number;
+    ts: number;
+}
+export type A2APolicyUpdatedFrame = JsonRpcNotification<"a2a.policy.updated", A2APolicyUpdatedParams>;
+export type A2AFrameMethod = "a2a.call" | "a2a.call.ack" | "a2a.progress" | "a2a.result" | "a2a.cancel" | "a2a.error" | "a2a.skill.updated" | "a2a.agent.retired" | "a2a.edge.revoked" | "a2a.context.event" | "a2a.policy.updated";
+export type A2AFrame = A2ACallFrame | A2ACallAckFrame | A2AProgressFrame | A2AResultFrame | A2ACancelFrame | A2AErrorFrame | A2ASkillUpdatedFrame | A2AAgentRetiredFrame | A2AEdgeRevokedFrame | A2AContextEventFrame | A2APolicyUpdatedFrame;
+export type HandshakeFrame = RegisterFrame | RegisteredFrame | PingFrame | PongFrame;
+export type AnyFrame = HandshakeFrame | A2AFrame;
+export declare const A2A_ERROR: {
+    readonly UNAUTHORIZED: -32000;
+    readonly FORBIDDEN: -32001;
+    readonly AGENT_UNAVAILABLE: -32002;
+    readonly AGENT_RETIRED: -32003;
+    readonly TOKEN_CARD_MISSING: -32004;
+    readonly RATE_LIMITED: -32005;
+    readonly CALL_TIMEOUT: -32006;
+    readonly INVALID_STATE: -32007;
+    readonly INVALID_PARENT: -32008;
+    readonly INVALID_CONTEXT: -32009;
+    readonly CONTEXT_ACCESS_DENIED: -32010;
+    readonly INVALID_FRAME: -32602;
+};
+export type A2AErrorCode = (typeof A2A_ERROR)[keyof typeof A2A_ERROR];
+export declare function isJsonRpcFrame(x: unknown): x is JsonRpcNotification;
+export declare function isA2AMethod(method: string): method is A2AFrameMethod;

package/dist/a2a-types.js

@@ -0,0 +1,59 @@
+/**
+ * Lattice A2A Protocol · v1 · Type Definitions
+ *
+ * Source of truth: .claude/a2a-protocol.md + .claude/a2a-spec.md
+ *
+ * All WS frames = JSON-RPC 2.0 Notification:
+ *   { jsonrpc: "2.0", method: <frame-name>, params: {...} }
+ *
+ * `params.taskId` correlates multi-frame exchanges (not JSON-RPC id/result).
+ */
+export const TERMINAL_STATES = new Set([
+    "completed",
+    "failed",
+    "canceled",
+    "rejected",
+]);
+/** Legal state transitions (a2a-spec.md §2.7 / a2a-protocol.md §4.3). */
+export const LEGAL_STATE_TRANSITIONS = new Map([
+    ["submitted", new Set(["working", "failed", "rejected", "canceled"])],
+    ["working", new Set(["completed", "failed", "canceled", "input-required", "auth-required"])],
+    ["input-required", new Set(["working", "canceled", "failed"])],
+    ["auth-required", new Set(["working", "canceled", "failed"])],
+    ["completed", new Set()],
+    ["failed", new Set()],
+    ["canceled", new Set()],
+    ["rejected", new Set()],
+]);
+export function isTerminal(state) {
+    return TERMINAL_STATES.has(state);
+}
+export function isLegalTransition(from, to) {
+    return LEGAL_STATE_TRANSITIONS.get(from)?.has(to) ?? false;
+}
+// ─── Error Codes (a2a-protocol.md §7 / a2a-spec.md §2.6) ────────────────────
+export const A2A_ERROR = {
+    UNAUTHORIZED: -32000,
+    FORBIDDEN: -32001, // aka NO_EDGE / ROLE_VIOLATION / SKILL_NOT_ALLOWED
+    AGENT_UNAVAILABLE: -32002,
+    AGENT_RETIRED: -32003,
+    TOKEN_CARD_MISSING: -32004, // also: TASK_NOT_FOUND (REST)
+    RATE_LIMITED: -32005, // aka ACCEPT_TIMEOUT when data.reason="accept_timeout"
+    CALL_TIMEOUT: -32006,
+    INVALID_STATE: -32007,
+    INVALID_PARENT: -32008,
+    INVALID_CONTEXT: -32009,
+    CONTEXT_ACCESS_DENIED: -32010,
+    INVALID_FRAME: -32602,
+};
+// ─── Convenience type guards ────────────────────────────────────────────────
+export function isJsonRpcFrame(x) {
+    return typeof x === "object" && x !== null
+        && x.jsonrpc === "2.0"
+        && typeof x.method === "string"
+        && typeof x.params === "object";
+}
+export function isA2AMethod(method) {
+    return method.startsWith("a2a.");
+}
+//# sourceMappingURL=a2a-types.js.map

package/dist/a2a-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-types.js","sourceRoot":"","sources":["../src/a2a-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsBH,MAAM,CAAC,MAAM,eAAe,GAA2B,IAAI,GAAG,CAAY;IACxE,WAAW;IACX,QAAQ;IACR,UAAU;IACV,UAAU;CACX,CAAC,CAAC;AAEH,yEAAyE;AACzE,MAAM,CAAC,MAAM,uBAAuB,GAAmD,IAAI,GAAG,CAAC;IAC7F,CAAC,WAAW,EAAE,IAAI,GAAG,CAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAChF,CAAC,SAAS,EAAE,IAAI,GAAG,CAAY,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC;IACvG,CAAC,gBAAgB,EAAE,IAAI,GAAG,CAAY,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;IACzE,CAAC,eAAe,EAAE,IAAI,GAAG,CAAY,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxE,CAAC,WAAW,EAAE,IAAI,GAAG,EAAa,CAAC;IACnC,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAa,CAAC;IAChC,CAAC,UAAU,EAAE,IAAI,GAAG,EAAa,CAAC;IAClC,CAAC,UAAU,EAAE,IAAI,GAAG,EAAa,CAAC;CACnC,CAAC,CAAC;AAEH,MAAM,UAAU,UAAU,CAAC,KAAgB;IACzC,OAAO,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAe,EAAE,EAAa;IAC9D,OAAO,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC;AAC7D,CAAC;AAsUD,+EAA+E;AAE/E,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,YAAY,EAAW,CAAC,KAAK;IAC7B,SAAS,EAAc,CAAC,KAAK,EAAE,mDAAmD;IAClF,iBAAiB,EAAM,CAAC,KAAK;IAC7B,aAAa,EAAU,CAAC,KAAK;IAC7B,kBAAkB,EAAK,CAAC,KAAK,EAAE,8BAA8B;IAC7D,YAAY,EAAW,CAAC,KAAK,EAAE,uDAAuD;IACtF,YAAY,EAAW,CAAC,KAAK;IAC7B,aAAa,EAAU,CAAC,KAAK;IAC7B,cAAc,EAAS,CAAC,KAAK;IAC7B,eAAe,EAAQ,CAAC,KAAK;IAC7B,qBAAqB,EAAE,CAAC,KAAK;IAC7B,aAAa,EAAU,CAAC,KAAK;CACrB,CAAC;AAIX,+EAA+E;AAE/E,MAAM,UAAU,cAAc,CAAC,CAAU;IACvC,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;WACpC,CAAS,CAAC,OAAO,KAAK,KAAK;WAC5B,OAAQ,CAAS,CAAC,MAAM,KAAK,QAAQ;WACrC,OAAQ,CAAS,CAAC,MAAM,KAAK,QAAQ,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc;IACxC,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC"}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export type { LobsterIdentity, LobsterInfo, MentionTarget, ClientMessage, ServerMessage, TelemetryRecord, TriggerUserInfo, Recommendation, LobbyAdapter, } from "./types.js";
+export type { TelemetryRecord, TriggerUserInfo, Recommendation, } from "./types.js";
 export { MODEL_PRICING, MODEL_ALIASES, computeCost, type ModelPrice, type CostSource, type CostResult, } from "./pricing.js";
+export { TERMINAL_STATES, LEGAL_STATE_TRANSITIONS, isTerminal, isLegalTransition, A2A_ERROR, isJsonRpcFrame, isA2AMethod, } from "./a2a-types.js";
+export type { JsonRpcNotification, TaskState, TextPart, FilePart, DataPart, ArtifactRefPart, Part, Message, Artifact, TaskStatus, TaskMetadata, Task, Context, SkillDef, AgentCardCapabilities, AgentCardLatticeOverlay, AgentCard, DirectoryAgentEntry, DirectorySnapshot, RegisterParams, RegisterFrame, RegisteredParams, RegisteredFrame, PingParams, PingFrame, PongParams, PongFrame, HandshakeFrame, A2ACallParams, A2ACallFrame, A2ACallAckParams, A2ACallAckFrame, A2AProgressParams, A2AProgressFrame, A2AResultParams, A2AResultFrame, A2ACancelParams, A2ACancelFrame, A2AErrorParams, A2AErrorFrame, A2ASkillUpdatedParams, A2ASkillUpdatedFrame, A2AAgentRetiredParams, A2AAgentRetiredFrame, A2AEdgeRevokedParams, A2AEdgeRevokedFrame, ContextEventKind, A2AContextEventParams, A2AContextEventFrame, A2APolicyUpdatedParams, A2APolicyUpdatedFrame, A2AFrameMethod, A2AFrame, AnyFrame, A2AErrorCode, } from "./a2a-types.js";

package/dist/index.js

@@ -1,2 +1,4 @@
 export { MODEL_PRICING, MODEL_ALIASES, computeCost, } from "./pricing.js";
+// ─── A2A Protocol v1 ────────────────────────────────────────────────────────
+export { TERMINAL_STATES, LEGAL_STATE_TRANSITIONS, isTerminal, isLegalTransition, A2A_ERROR, isJsonRpcFrame, isA2AMethod, } from "./a2a-types.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,aAAa,EACb,aAAa,EACb,WAAW,GAIZ,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,aAAa,EACb,aAAa,EACb,WAAW,GAIZ,MAAM,cAAc,CAAC;AAEtB,+EAA+E;AAE/E,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,UAAU,EACV,iBAAiB,EACjB,SAAS,EACT,cAAc,EACd,WAAW,GACZ,MAAM,gBAAgB,CAAC"}

package/dist/types.d.ts

@@ -1,108 +1,9 @@
 /**
  * Flow-A2A — Shared Protocol Types
  *
- * Extends reef's protocol with telemetry message types.
  * Used by plugin (client), center (server), and shared tooling.
+ * All WS communication uses JSON-RPC 2.0 framing (see a2a-types.ts).
  */
-export interface LobsterIdentity {
-    lobsterId: string;
-    name: string;
-    botOpenId?: string;
-    groups?: string[];
-    meta?: Record<string, unknown>;
-}
-export interface LobsterInfo {
-    id: string;
-    name: string;
-    botOpenId?: string;
-    groups: string[];
-    connectedAt: number;
-    meta?: Record<string, unknown>;
-}
-export interface MentionTarget {
-    name: string;
-    openId?: string;
-}
-export type ClientMessage = ({
-    type: "register";
-    token?: string;
-} & LobsterIdentity) | {
-    type: "lobby";
-    text: string;
-} | {
-    type: "dm";
-    to: string;
-    text: string;
-} | {
-    type: "feishu";
-    chatId: string;
-    text: string;
-    messageId?: string;
-    threadId?: string;
-    mentions?: MentionTarget[];
-} | {
-    type: "history";
-} | {
-    type: "ping";
-} | {
-    type: "who";
-} | {
-    type: "telemetry";
-    batch: TelemetryRecord[];
-};
-export type ServerMessage = {
-    type: "registered";
-    lobsterId: string;
-    lobsters: LobsterInfo[];
-} | {
-    type: "lobby";
-    from: string;
-    fromName: string;
-    text: string;
-    ts: number;
-} | {
-    type: "dm";
-    from: string;
-    fromName: string;
-    text: string;
-    ts: number;
-    echo?: boolean;
-} | {
-    type: "feishu";
-    from: string;
-    fromName: string;
-    fromBotOpenId: string;
-    chatId: string;
-    text: string;
-    messageId: string;
-    threadId?: string;
-    ts: number;
-} | {
-    type: "join";
-    lobsterId: string;
-    name: string;
-    ts: number;
-} | {
-    type: "leave";
-    lobsterId: string;
-    name: string;
-    ts: number;
-} | {
-    type: "history";
-    messages: ServerMessage[];
-} | {
-    type: "who";
-    lobsters: LobsterInfo[];
-} | {
-    type: "pong";
-} | {
-    type: "error";
-    message: string;
-} | {
-    type: "telemetry_ack";
-    accepted: number;
-    errors?: string[];
-};
 export interface TelemetryRecord {
     kind: "llm" | "tool";
     ts: number;
@@ -145,33 +46,3 @@ export interface Recommendation {
     estimatedSavingsUsd: number | null;
     confidence: "high" | "medium" | "low";
 }
-export interface LobbyAdapter {
-    onLobbyMessage?(msg: {
-        from: string;
-        fromName: string;
-        text: string;
-        ts: number;
-    }): void;
-    onDirectMessage?(msg: {
-        from: string;
-        fromName: string;
-        text: string;
-        ts: number;
-    }): void;
-    onFeishuRelay?(msg: {
-        from: string;
-        fromName: string;
-        fromBotOpenId: string;
-        chatId: string;
-        text: string;
-        messageId: string;
-        threadId?: string;
-        ts: number;
-    }): void;
-    onPresence?(msg: {
-        type: "join" | "leave";
-        lobsterId: string;
-        name: string;
-    }): void;
-    onHistory?(messages: ServerMessage[]): void;
-}

package/dist/types.js

@@ -1,8 +1,8 @@
 /**
  * Flow-A2A — Shared Protocol Types
  *
- * Extends reef's protocol with telemetry message types.
  * Used by plugin (client), center (server), and shared tooling.
+ * All WS communication uses JSON-RPC 2.0 framing (see a2a-types.ts).
  */
 export {};
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flow-a2a/shared",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Shared types, protocol definitions, and pricing logic for Flow-A2A",
   "type": "module",
   "license": "MIT",