overai 1.4.27 → 1.4.29

package/README.md

@@ -4,12 +4,16 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Downloads](https://img.shields.io/npm/dm/overai.svg)](https://www.npmjs.com/package/overai)
 
-![OverAI Logo](https://cdn.jsdelivr.net/npm/overai@1.4.26/images/overai.png)
+![OverAI Logo](https://cdn.jsdelivr.net/npm/overai@latest/images/overai.png)
 
 **OverAI** is the comprehensive, production-ready AI Agents framework designed for **Builders, Entrepreneurs, and Enterprise Developers**. 
 
 Unlike other frameworks that stop at "Hello World", OverAI provides the full stack needed to **Build, Deploy, and Monetize** AI solutions. From simple automation scripts to full-fledged AI SaaS platforms with billing, API keys, and workflow integrations.
 
+## 📣 Join the Community
+
+Follow this link to join the WhatsApp group: [Join the WhatsApp Community](https://chat.whatsapp.com/JbXwPg47gJ56Fi9lnAeHy9)
+
 ## 🚀 Why Choose OverAI?
 
 ### 💼 For Entrepreneurs & SaaS Builders
@@ -322,6 +326,55 @@ Support for the MCP standard allows your agents to safely access local files, da
 
 ---
 
+## 🤝 A2A (Agent‑to‑Agent) Optionnel
+
+OverAI fournit une couche A2A optionnelle pour la négociation et la coordination entre agents, activable à la demande et sans modifier vos agents existants.
+
+- Activer la couche A2A par variable d’environnement:
+  ```bash
+  export OVERAI_A2A_ENABLED=true
+  ```
+- Imports publics:
+  ```typescript
+  import { Agent, Router } from 'overai';
+  import { ChannelManager, OverAIAdapter } from 'overai/a2a';
+  ```
+- Exemple minimal:
+  ```typescript
+  const cm = new ChannelManager(); // activé si OVERAI_A2A_ENABLED=true
+  const writer = new Agent({ instructions: 'Tu rédiges des fiches produit' });
+  const seo = new Agent({ instructions: 'Tu optimises SEO' });
+
+  const router = new Router({
+    writer: { agent: writer, keywords: ['rédige', 'fiche'] },
+    seo: { agent: seo, keywords: ['seo', 'métadonnées', 'balises'] }
+  }, { default: 'writer' });
+
+  const a2a = new OverAIAdapter({
+    channel: cm,
+    agents: { writer, seo },
+    router
+  });
+
+  cm.openChannel('ch-1', ['writer', 'seo']);
+  await a2a.handle({
+    type: 'propose',
+    channelId: 'ch-1',
+    from: 'writer',
+    to: 'seo',
+    timestamp: Date.now(),
+    taskId: 'task-123',
+    proposal: {
+      goal: 'Optimiser la fiche produit pour SEO',
+      steps: ['mots-clés', 'meta', 'FAQ', 'JSON-LD']
+    }
+  });
+  ```
+
+Cette couche est facultative et isolée: si OVERAI_A2A_ENABLED n’est pas défini à true, le module reste inactif et vos agents fonctionnent comme d’habitude.
+
+---
+
 ## 🛠️ Development
 
 To contribute or modify the framework:

package/dist/a2a/adapters/overai.d.ts

@@ -0,0 +1,21 @@
+import type { A2AMessage } from '../messages';
+import { ChannelManager } from '../channel';
+import { Agent } from '../../agent/simple';
+import { Router } from '../../agent/router';
+export interface OverAIAdapterConfig {
+    channel: ChannelManager;
+    agents: Record<string, Agent>;
+    router?: Router;
+}
+export declare class OverAIAdapter {
+    private channel;
+    private agents;
+    private router?;
+    private machines;
+    constructor(config: OverAIAdapterConfig);
+    private getMachine;
+    handle(message: A2AMessage): Promise<void>;
+    private onPropose;
+    private onHandoff;
+    private onCommit;
+}

package/dist/a2a/adapters/overai.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverAIAdapter = void 0;
+const state_1 = require("../state");
+class OverAIAdapter {
+    constructor(config) {
+        this.machines = new Map();
+        this.channel = config.channel;
+        this.agents = config.agents;
+        this.router = config.router;
+    }
+    getMachine(channelId) {
+        let m = this.machines.get(channelId);
+        if (!m) {
+            m = new state_1.NegotiationStateMachine();
+            this.machines.set(channelId, m);
+        }
+        return m;
+    }
+    async handle(message) {
+        const machine = this.getMachine(message.channelId);
+        machine.apply(message);
+        this.channel.send(message);
+        switch (message.type) {
+            case 'propose':
+                await this.onPropose(message);
+                break;
+            case 'handoff':
+                await this.onHandoff(message);
+                break;
+            case 'commit':
+                await this.onCommit(message);
+                break;
+            default:
+                // control messages handled by state machine only
+                break;
+        }
+    }
+    async onPropose(msg) {
+        const target = msg.to && this.agents[msg.to];
+        const prompt = `Objectif: ${msg.proposal.goal}\n` +
+            `Étapes: ${(msg.proposal.steps || []).join(' | ')}\n` +
+            `Contraintes: ${(msg.proposal.constraints || []).join(' | ')}\n` +
+            `Ressources: ${JSON.stringify(msg.proposal.resources || {})}`;
+        if (target) {
+            const out = await target.start(prompt);
+            const commit = {
+                type: 'commit',
+                channelId: msg.channelId,
+                from: msg.to,
+                to: msg.from,
+                timestamp: Date.now(),
+                taskId: msg.taskId,
+                result: { success: true, output: out }
+            };
+            await this.handle(commit);
+        }
+        else if (this.router) {
+            const result = await this.router.chat(prompt);
+            const commit = {
+                type: 'commit',
+                channelId: msg.channelId,
+                from: 'router',
+                to: msg.from,
+                timestamp: Date.now(),
+                taskId: msg.taskId,
+                result: { success: true, output: result }
+            };
+            await this.handle(commit);
+        }
+    }
+    async onHandoff(msg) {
+        const next = this.agents[msg.nextAgent];
+        if (!next)
+            return;
+        const ctx = msg.context || {};
+        const prompt = `Reprise (handoff) avec contexte: ${JSON.stringify(ctx)}`;
+        const out = await next.start(prompt);
+        const commit = {
+            type: 'commit',
+            channelId: msg.channelId,
+            from: msg.nextAgent,
+            to: msg.from,
+            timestamp: Date.now(),
+            taskId: msg.taskId,
+            result: { success: true, output: out }
+        };
+        await this.handle(commit);
+    }
+    async onCommit(_msg) {
+        // noop: already audited by channel + state machine
+    }
+}
+exports.OverAIAdapter = OverAIAdapter;

package/dist/a2a/channel.d.ts

@@ -0,0 +1,23 @@
+import type { A2AMessage, AgentId, ChannelId } from './messages';
+export interface ChannelRecord {
+    id: ChannelId;
+    participants: Set<AgentId>;
+    audit: A2AMessage[];
+    createdAt: number;
+    metadata?: Record<string, any>;
+}
+export declare class ChannelManager {
+    private channels;
+    private agents;
+    private enabled;
+    static isEnabledEnv(): boolean;
+    constructor(enabled?: boolean);
+    isEnabled(): boolean;
+    registerAgent(agentId: AgentId): void;
+    hasAgent(agentId: AgentId): boolean;
+    openChannel(id: ChannelId, participants: AgentId[], metadata?: Record<string, any>): ChannelRecord;
+    getChannel(id: ChannelId): ChannelRecord | undefined;
+    closeChannel(id: ChannelId): boolean;
+    send(message: A2AMessage): void;
+    getAudit(id: ChannelId): A2AMessage[];
+}

package/dist/a2a/channel.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+class ChannelManager {
+    static isEnabledEnv() {
+        const flag = process.env.OVERAI_A2A_ENABLED;
+        return String(flag).toLowerCase() === 'true';
+    }
+    constructor(enabled = ChannelManager.isEnabledEnv()) {
+        this.channels = new Map();
+        this.agents = new Set();
+        this.enabled = enabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    registerAgent(agentId) {
+        this.agents.add(agentId);
+    }
+    hasAgent(agentId) {
+        return this.agents.has(agentId);
+    }
+    openChannel(id, participants, metadata) {
+        const record = {
+            id,
+            participants: new Set(participants),
+            audit: [],
+            createdAt: Date.now(),
+            metadata
+        };
+        this.channels.set(id, record);
+        return record;
+    }
+    getChannel(id) {
+        return this.channels.get(id);
+    }
+    closeChannel(id) {
+        return this.channels.delete(id);
+    }
+    send(message) {
+        const channel = this.channels.get(message.channelId);
+        if (!channel) {
+            throw new Error(`Channel not found: ${message.channelId}`);
+        }
+        channel.audit.push(message);
+    }
+    getAudit(id) {
+        const channel = this.channels.get(id);
+        return channel ? [...channel.audit] : [];
+    }
+}
+exports.ChannelManager = ChannelManager;

package/dist/a2a/index.d.ts

@@ -0,0 +1,4 @@
+export * from './messages';
+export * from './channel';
+export * from './state';
+export * from './adapters/overai';

package/dist/a2a/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./messages"), exports);
+__exportStar(require("./channel"), exports);
+__exportStar(require("./state"), exports);
+__exportStar(require("./adapters/overai"), exports);

package/dist/a2a/messages.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A2A-like Message Schema (optional layer)
+ *
+ * Defines normalized message types for agent-to-agent negotiation and coordination.
+ */
+export type AgentId = string;
+export type ChannelId = string;
+export type TaskId = string;
+export interface BaseMessage {
+    type: 'propose' | 'accept' | 'reject' | 'revise' | 'handoff' | 'commit' | 'status' | 'error';
+    channelId: ChannelId;
+    from: AgentId;
+    to?: AgentId;
+    taskId?: TaskId;
+    correlationId?: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+export interface ProposeMessage extends BaseMessage {
+    type: 'propose';
+    proposal: {
+        goal: string;
+        steps?: string[];
+        constraints?: string[];
+        resources?: Record<string, any>;
+    };
+}
+export interface AcceptMessage extends BaseMessage {
+    type: 'accept';
+    acceptedProposalId?: string;
+}
+export interface RejectMessage extends BaseMessage {
+    type: 'reject';
+    reason?: string;
+    suggestedRevision?: string;
+}
+export interface ReviseMessage extends BaseMessage {
+    type: 'revise';
+    revision: {
+        changes: string[];
+    };
+}
+export interface HandoffMessage extends BaseMessage {
+    type: 'handoff';
+    nextAgent: AgentId;
+    context?: Record<string, any>;
+}
+export interface CommitMessage extends BaseMessage {
+    type: 'commit';
+    result?: {
+        success: boolean;
+        output?: any;
+        logs?: string[];
+    };
+}
+export interface StatusMessage extends BaseMessage {
+    type: 'status';
+    status: 'pending' | 'negotiating' | 'in_progress' | 'blocked' | 'completed' | 'failed';
+    details?: string;
+}
+export interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, any>;
+    };
+}
+export type A2AMessage = ProposeMessage | AcceptMessage | RejectMessage | ReviseMessage | HandoffMessage | CommitMessage | StatusMessage | ErrorMessage;

package/dist/a2a/messages.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * A2A-like Message Schema (optional layer)
+ *
+ * Defines normalized message types for agent-to-agent negotiation and coordination.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/a2a/state.d.ts

@@ -0,0 +1,9 @@
+import type { A2AMessage } from './messages';
+export type NegotiationState = 'idle' | 'proposed' | 'accepted' | 'rejected' | 'revising' | 'handoff' | 'committed' | 'failed';
+export declare class NegotiationStateMachine {
+    private state;
+    private history;
+    getState(): NegotiationState;
+    getHistory(): A2AMessage[];
+    apply(message: A2AMessage): NegotiationState;
+}

package/dist/a2a/state.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NegotiationStateMachine = void 0;
+class NegotiationStateMachine {
+    constructor() {
+        this.state = 'idle';
+        this.history = [];
+    }
+    getState() {
+        return this.state;
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    apply(message) {
+        this.history.push(message);
+        switch (message.type) {
+            case 'propose':
+                this.state = 'proposed';
+                break;
+            case 'accept':
+                this.state = 'accepted';
+                break;
+            case 'reject':
+                this.state = 'rejected';
+                break;
+            case 'revise':
+                this.state = 'revising';
+                break;
+            case 'handoff':
+                this.state = 'handoff';
+                break;
+            case 'commit':
+                this.state = 'committed';
+                break;
+            case 'error':
+                this.state = 'failed';
+                break;
+            default:
+                // status messages do not change state directly
+                break;
+        }
+        return this.state;
+    }
+}
+exports.NegotiationStateMachine = NegotiationStateMachine;

package/package.json

@@ -1,9 +1,20 @@
 {
   "name": "overai",
-  "version": "1.4.27",
+  "version": "1.4.29",
   "description": "OverAI TypeScript AI Agents Framework - Build, Deploy, and Monetize AI Agents in Minutes",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./a2a": {
+      "types": "./dist/a2a/index.d.ts",
+      "default": "./dist/a2a/index.js"
+    }
+  },
+  "readmeFilename": "README.md",
   "files": [
     "dist",
     "images",