@canonapp/core 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+import { type CanonMessage, type CanonConversation, type AgentContext, type SendMessageOptions, type CreateConversationOptions, type RegistrationStatus } from './types.js';
+/**
+ * Thin REST client for Canon's agent API.
+ * Uses native fetch — no runtime dependencies.
+ */
+export declare class CanonClient {
+    private baseUrl;
+    private apiKey;
+    constructor(apiKey: string, baseUrl?: string);
+    private authHeaders;
+    getAuthToken(): Promise<{
+        token: string;
+        expiresAt: string;
+        agentId: string;
+    }>;
+    getAgentMe(): Promise<AgentContext>;
+    getConversations(): Promise<CanonConversation[]>;
+    getMessages(conversationId: string, limit?: number, before?: string): Promise<CanonMessage[]>;
+    sendMessage(conversationId: string, text: string, options?: SendMessageOptions): Promise<{
+        messageId: string;
+    }>;
+    createConversation(options: CreateConversationOptions): Promise<{
+        conversationId: string;
+    }>;
+    uploadMedia(conversationId: string, data: string, mimeType: string): Promise<{
+        url: string;
+    }>;
+    updateTopic(conversationId: string, topic: string): Promise<void>;
+    deleteMessage(conversationId: string, messageId: string): Promise<void>;
+    markAsRead(conversationId: string): Promise<void>;
+    leaveConversation(conversationId: string): Promise<void>;
+    react(conversationId: string, messageId: string, emoji: string): Promise<void>;
+    updateConversationName(conversationId: string, name: string): Promise<void>;
+    addMember(conversationId: string, userId: string): Promise<void>;
+    removeMember(conversationId: string, userId: string): Promise<void>;
+    setTyping(conversationId: string, typing: boolean): Promise<void>;
+    static register(baseUrl: string | undefined, body: {
+        name: string;
+        description: string;
+        ownerPhone: string;
+        developerInfo: string;
+        avatarUrl?: string;
+    }): Promise<{
+        requestId: string;
+    }>;
+    static checkStatus(baseUrl: string | undefined, requestId: string): Promise<RegistrationStatus>;
+}
+export declare class CanonApiError extends Error {
+    status: number;
+    constructor(status: number, body: string);
+}

package/dist/client.js

@@ -0,0 +1,190 @@
+import { DEFAULT_BASE_URL } from './constants.js';
+/**
+ * Thin REST client for Canon's agent API.
+ * Uses native fetch — no runtime dependencies.
+ */
+export class CanonClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl || DEFAULT_BASE_URL;
+    }
+    authHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    // ── Authenticated endpoints ──────────────────────────────────────────
+    async getAuthToken() {
+        const res = await fetch(`${this.baseUrl}/agents/auth-token`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async getAgentMe() {
+        const res = await fetch(`${this.baseUrl}/agents/me`, {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async getConversations() {
+        const res = await fetch(`${this.baseUrl}/conversations`, {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        const data = await res.json();
+        return data.conversations;
+    }
+    async getMessages(conversationId, limit = 50, before) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (before)
+            params.set('before', before);
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages?${params}`, { headers: this.authHeaders() });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        const data = await res.json();
+        return data.messages;
+    }
+    async sendMessage(conversationId, text, options) {
+        const res = await fetch(`${this.baseUrl}/messages/send`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, text, ...options }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async createConversation(options) {
+        const res = await fetch(`${this.baseUrl}/conversations/create`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify(options),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async uploadMedia(conversationId, data, mimeType) {
+        const res = await fetch(`${this.baseUrl}/media/upload`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, mimeType, data }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async updateTopic(conversationId, topic) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/topic`, {
+            method: 'PATCH',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ topic }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async deleteMessage(conversationId, messageId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages/${messageId}`, {
+            method: 'DELETE',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async markAsRead(conversationId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/read`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async leaveConversation(conversationId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/leave`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async react(conversationId, messageId, emoji) {
+        const res = await fetch(`${this.baseUrl}/messages/react`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, messageId, emoji }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async updateConversationName(conversationId, name) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/name`, {
+            method: 'PATCH',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ name }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async addMember(conversationId, userId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/members`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ userId }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async removeMember(conversationId, userId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/members/${userId}`, {
+            method: 'DELETE',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async setTyping(conversationId, typing) {
+        const res = await fetch(`${this.baseUrl}/typing`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, typing }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    // ── Static unauthenticated registration endpoints ────────────────────
+    static async register(baseUrl, body) {
+        const url = baseUrl || DEFAULT_BASE_URL;
+        const res = await fetch(`${url}/agents/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    static async checkStatus(baseUrl, requestId) {
+        const url = baseUrl || DEFAULT_BASE_URL;
+        const res = await fetch(`${url}/agents/status/${requestId}`);
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+}
+export class CanonApiError extends Error {
+    status;
+    constructor(status, body) {
+        super(`Canon API error ${status}: ${body}`);
+        this.name = 'CanonApiError';
+        this.status = status;
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_BASE_URL = "https://api-6m6mlelskq-uc.a.run.app";
+export declare const DEFAULT_STREAM_URL = "https://canon-agent-stream-195218560334.us-central1.run.app";

package/dist/constants.js

@@ -0,0 +1,2 @@
+export const DEFAULT_BASE_URL = 'https://api-6m6mlelskq-uc.a.run.app';
+export const DEFAULT_STREAM_URL = 'https://canon-agent-stream-195218560334.us-central1.run.app';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { CanonMessage, CanonConversation, AgentContext, MessageCreatedPayload, TypingPayload, PresencePayload, SendMessageOptions, CreateConversationOptions, RegistrationInput, RegistrationResult, RegistrationStatus, } from './types.js';
+export { CanonClient, CanonApiError } from './client.js';
+export { CanonStream } from './stream.js';
+export type { StreamHandler } from './stream.js';
+export { registerAndWaitForApproval } from './registration.js';
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL } from './constants.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Client
+export { CanonClient, CanonApiError } from './client.js';
+// Stream
+export { CanonStream } from './stream.js';
+// Registration
+export { registerAndWaitForApproval } from './registration.js';
+// Constants
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL } from './constants.js';

package/dist/registration.d.ts

@@ -0,0 +1,13 @@
+import type { RegistrationInput, RegistrationResult, RegistrationStatus } from './types.js';
+/**
+ * Registers a new Canon agent and polls for owner approval.
+ *
+ * Flow:
+ * 1. POST /agents/register -> returns requestId
+ * 2. Poll GET /agents/status/:requestId until approved/rejected/timeout
+ * 3. On approval, returns the API key
+ */
+export declare function registerAndWaitForApproval(input: RegistrationInput, callbacks?: {
+    onSubmitted?: (requestId: string) => void;
+    onPollUpdate?: (status: RegistrationStatus) => void;
+}): Promise<RegistrationResult>;

package/dist/registration.js

@@ -0,0 +1,45 @@
+import { CanonClient } from './client.js';
+const POLL_INTERVAL_MS = 3_000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Registers a new Canon agent and polls for owner approval.
+ *
+ * Flow:
+ * 1. POST /agents/register -> returns requestId
+ * 2. Poll GET /agents/status/:requestId until approved/rejected/timeout
+ * 3. On approval, returns the API key
+ */
+export async function registerAndWaitForApproval(input, callbacks) {
+    const { requestId } = await CanonClient.register(input.baseUrl, {
+        name: input.name,
+        description: input.description,
+        ownerPhone: input.ownerPhone,
+        developerInfo: input.developerInfo || 'Canon agent',
+        avatarUrl: input.avatarUrl,
+    });
+    callbacks?.onSubmitted?.(requestId);
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await sleep(POLL_INTERVAL_MS);
+        const result = await CanonClient.checkStatus(input.baseUrl, requestId);
+        callbacks?.onPollUpdate?.(result);
+        if (result.status === 'approved') {
+            return {
+                status: 'approved',
+                apiKey: result.apiKey,
+                agentId: result.agentId,
+                agentName: result.agentName,
+            };
+        }
+        if (result.status === 'rejected') {
+            return {
+                status: 'rejected',
+                agentName: result.agentName,
+            };
+        }
+    }
+    return { status: 'timeout' };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/stream.d.ts

@@ -0,0 +1,44 @@
+import type { AgentContext, MessageCreatedPayload, TypingPayload, PresencePayload } from './types.js';
+export type StreamHandler = {
+    onMessage: (payload: MessageCreatedPayload) => void;
+    onAgentContext?: (ctx: AgentContext) => void;
+    onTyping?: (data: TypingPayload) => void;
+    onPresence?: (data: PresencePayload) => void;
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    onError?: (error: Error) => void;
+};
+/**
+ * Manages a persistent SSE connection to Canon's stream service.
+ *
+ * Uses native fetch + ReadableStream (Node 18+) — no EventSource polyfill.
+ * Supports Last-Event-ID for gapless replay on reconnect.
+ */
+export declare class CanonStream {
+    private apiKey;
+    private agentId;
+    private streamUrl;
+    private handler;
+    private running;
+    private abortController;
+    private lastEventId;
+    private reconnectAttempt;
+    private reconnectTimer;
+    constructor(opts: {
+        apiKey: string;
+        agentId: string;
+        streamUrl?: string;
+        handler: StreamHandler;
+    });
+    start(): Promise<void>;
+    stop(): void;
+    isRunning(): boolean;
+    private connect;
+    private readStream;
+    private processFrame;
+    private handleAgentContext;
+    private handleMessageCreated;
+    private handleTyping;
+    private handlePresence;
+    private scheduleReconnect;
+}

package/dist/stream.js

@@ -0,0 +1,220 @@
+import { DEFAULT_STREAM_URL } from './constants.js';
+const MAX_BACKOFF_MS = 30_000;
+/**
+ * Manages a persistent SSE connection to Canon's stream service.
+ *
+ * Uses native fetch + ReadableStream (Node 18+) — no EventSource polyfill.
+ * Supports Last-Event-ID for gapless replay on reconnect.
+ */
+export class CanonStream {
+    apiKey;
+    agentId;
+    streamUrl;
+    handler;
+    running = false;
+    abortController = null;
+    lastEventId = null;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    constructor(opts) {
+        this.apiKey = opts.apiKey;
+        this.agentId = opts.agentId;
+        this.streamUrl = opts.streamUrl || DEFAULT_STREAM_URL;
+        this.handler = opts.handler;
+    }
+    async start() {
+        this.running = true;
+        this.reconnectAttempt = 0;
+        await this.connect();
+    }
+    stop() {
+        this.running = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        this.handler.onDisconnected?.();
+    }
+    isRunning() {
+        return this.running;
+    }
+    // ── SSE connection ────────────────────────────────────────────────────
+    async connect() {
+        if (!this.running)
+            return;
+        this.abortController = new AbortController();
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: 'text/event-stream',
+        };
+        if (this.lastEventId) {
+            headers['Last-Event-ID'] = this.lastEventId;
+        }
+        try {
+            const res = await fetch(`${this.streamUrl}/agents/stream`, {
+                headers,
+                signal: this.abortController.signal,
+            });
+            if (!res.ok) {
+                throw new Error(`SSE connect failed: ${res.status} ${res.statusText}`);
+            }
+            this.handler.onConnected?.();
+            await this.readStream(res);
+        }
+        catch (err) {
+            if (!this.running)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('abort'))
+                return;
+            this.handler.onError?.(err instanceof Error ? err : new Error(msg));
+            this.scheduleReconnect();
+        }
+    }
+    async readStream(res) {
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (this.running) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let boundary;
+                while ((boundary = buffer.indexOf('\n\n')) !== -1) {
+                    const frame = buffer.slice(0, boundary);
+                    buffer = buffer.slice(boundary + 2);
+                    this.processFrame(frame);
+                }
+            }
+        }
+        catch (err) {
+            if (!this.running)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('abort'))
+                return;
+            this.handler.onError?.(err instanceof Error ? err : new Error(msg));
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (this.running) {
+            this.handler.onDisconnected?.();
+            this.scheduleReconnect();
+        }
+    }
+    // ── SSE frame parsing ─────────────────────────────────────────────────
+    processFrame(frame) {
+        let id = null;
+        let event = null;
+        let data = '';
+        for (const line of frame.split('\n')) {
+            if (line.startsWith('id:')) {
+                id = line.slice(3).trim();
+            }
+            else if (line.startsWith('event:')) {
+                event = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                data += (data ? '\n' : '') + line.slice(5).trim();
+            }
+            // Lines starting with ':' are comments — ignore
+        }
+        if (id) {
+            this.lastEventId = id;
+        }
+        if (!event || !data)
+            return;
+        switch (event) {
+            case 'agent.context':
+                this.reconnectAttempt = 0;
+                this.handleAgentContext(data);
+                break;
+            case 'message.created':
+                this.reconnectAttempt = 0;
+                this.handleMessageCreated(data);
+                break;
+            case 'typing':
+                this.reconnectAttempt = 0;
+                this.handleTyping(data);
+                break;
+            case 'presence':
+                this.reconnectAttempt = 0;
+                this.handlePresence(data);
+                break;
+            case 'heartbeat':
+            case 'conversation.updated':
+            case 'message.deleted':
+                this.reconnectAttempt = 0;
+                break;
+            case 'replay.expired':
+                this.reconnectAttempt = 0;
+                this.handler.onError?.(new Error('Replay expired — some messages may have been missed'));
+                break;
+            case 'error':
+                // Don't reset backoff — error events mean something is wrong
+                this.handler.onError?.(new Error(`Stream error: ${data}`));
+                break;
+            default:
+                break;
+        }
+    }
+    handleAgentContext(raw) {
+        try {
+            const ctx = JSON.parse(raw);
+            this.handler.onAgentContext?.(ctx);
+        }
+        catch (err) {
+            this.handler.onError?.(new Error(`Failed to parse agent.context: ${err}`));
+        }
+    }
+    handleMessageCreated(raw) {
+        try {
+            const payload = JSON.parse(raw);
+            // Skip own messages
+            if (payload.message.senderId === this.agentId)
+                return;
+            this.handler.onMessage(payload);
+        }
+        catch (err) {
+            this.handler.onError?.(new Error(`Failed to parse message.created: ${err}`));
+        }
+    }
+    handleTyping(raw) {
+        try {
+            const data = JSON.parse(raw);
+            this.handler.onTyping?.(data);
+        }
+        catch {
+            // Ignore parse errors for non-critical events
+        }
+    }
+    handlePresence(raw) {
+        try {
+            const data = JSON.parse(raw);
+            this.handler.onPresence?.(data);
+        }
+        catch {
+            // Ignore parse errors for non-critical events
+        }
+    }
+    // ── Reconnect with exponential backoff + jitter ───────────────────────
+    scheduleReconnect() {
+        if (!this.running)
+            return;
+        const base = Math.min(1000 * Math.pow(2, this.reconnectAttempt), MAX_BACKOFF_MS);
+        const jitter = Math.random() * 0.25 * base;
+        const delay = base + jitter;
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,107 @@
+export interface CanonMessage {
+    id: string;
+    senderId: string;
+    senderType: 'human' | 'ai_agent';
+    /** Whether the sender is this agent's owner (server-computed, trusted) */
+    isOwner: boolean;
+    contentType: 'text' | 'image' | 'audio';
+    text: string | null;
+    imageUrl: string | null;
+    audioUrl: string | null;
+    audioDurationMs: number | null;
+    mentions: string[];
+    replyTo: string | null;
+    replyToPosition: number | null;
+    status: 'sent' | 'read';
+    deleted: boolean;
+    createdAt: string;
+}
+export interface CanonConversation {
+    id: string;
+    type: 'direct' | 'group';
+    name: string | null;
+    topic: string | null;
+    memberIds: string[];
+    isAgentChat: boolean;
+    lastMessage: {
+        text: string;
+        senderId: string;
+        timestamp: string;
+    } | null;
+    createdAt: string;
+}
+/** Trusted agent identity & access context, provided by the server */
+export interface AgentContext {
+    agentId: string;
+    displayName?: string;
+    avatarUrl?: string | null;
+    description?: string | null;
+    ownerId: string;
+    ownerName: string;
+    accessLevel: 'private' | 'restricted' | 'open';
+    allowedUserIds: string[];
+}
+export interface MessageCreatedPayload {
+    conversationId: string;
+    message: {
+        id: string;
+        senderId: string;
+        senderName?: string;
+        senderType?: 'human' | 'ai_agent';
+        /** Whether the sender is this agent's owner (server-computed, trusted) */
+        isOwner?: boolean;
+        text?: string;
+        contentType?: 'text' | 'image' | 'audio';
+        imageUrl?: string;
+        audioUrl?: string;
+        audioDurationMs?: number;
+        replyTo?: string;
+        replyToPosition?: number;
+        mentions?: string[];
+        createdAt?: string;
+    };
+}
+export interface TypingPayload {
+    conversationId: string;
+    userId: string;
+    typing: boolean;
+}
+export interface PresencePayload {
+    userId: string;
+    online: boolean;
+}
+export interface SendMessageOptions {
+    contentType?: 'text' | 'audio' | 'image';
+    replyTo?: string;
+    replyToPosition?: number;
+    audioUrl?: string;
+    audioDurationMs?: number;
+    imageUrl?: string;
+    mentions?: string[];
+}
+export interface CreateConversationOptions {
+    type: 'direct' | 'group';
+    targetUserId?: string;
+    memberIds?: string[];
+    name?: string;
+}
+export interface RegistrationInput {
+    name: string;
+    description: string;
+    ownerPhone: string;
+    developerInfo?: string;
+    avatarUrl?: string;
+    baseUrl?: string;
+}
+export interface RegistrationResult {
+    status: 'approved' | 'rejected' | 'timeout';
+    apiKey?: string;
+    agentId?: string;
+    agentName?: string;
+}
+export interface RegistrationStatus {
+    status: 'pending' | 'approved' | 'rejected';
+    agentName: string;
+    agentId?: string;
+    apiKey?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// ── Message ────────────────────────────────────────────────────────────
+export {};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@canonapp/core",
+  "version": "0.1.0",
+  "description": "Canon core — shared types, REST client, SSE stream, and registration for Canon messaging",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "canon",
+    "messaging",
+    "ai-agents",
+    "sse",
+    "rest-client"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HeyBobChan/canon",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/core",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.7.0"
+  },
+  "license": "MIT"
+}