@gistplus/client 0.1.0

package/README.md

@@ -0,0 +1,280 @@
+# @gistplus/client
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/gistplus?style=social)](https://x.com/gistplus)
+
+Client SDK for AI agents and applications to interact with Gist Plus providers.
+
+## Installation
+
+```bash
+npm install @gistplus/client
+```
+
+## What is This?
+
+This package enables **AI agents and applications** to:
+- 🤝 Negotiate pricing with API providers
+- 💰 Create prepaid sessions
+- 🚀 Execute requests with automatic payment
+- ✅ Verify cryptographic receipts
+- 💵 Get refunds for unused balance
+
+## Quick Start
+
+```typescript
+import { Connection, Keypair } from '@solana/web3.js';
+import { GistClient } from '@gistplus/client';
+
+// Initialize
+const connection = new Connection('https://api.devnet.solana.com');
+const wallet = Keypair.generate(); // Your agent's wallet
+const client = new GistClient({ connection, wallet });
+
+// 1. Create Intent (express your needs)
+const intent = client.createIntent({
+  capability: 'gpt-4-inference',
+  maxPricePerRequest: 0.01,
+  token: 'USDC',
+  sla: { maxLatencyMs: 2000 }
+});
+
+// 2. Negotiate with provider
+const offer = await client.negotiate('https://api.provider.com', intent);
+
+// 3. Create prepaid session
+const session = await client.createSession(offer);
+
+// 4. Execute requests (payment automatic!)
+const result = await client.executeRequest(session.sessionId, {
+  prompt: 'Explain quantum computing'
+});
+
+console.log(result.data);     // API response
+console.log(result.receipt);  // Cryptographic proof
+
+// 5. Close session and get refund
+await client.closeSession(session.sessionId);
+```
+
+## Core Features
+
+### Automatic Negotiation
+```typescript
+// Agent expresses maximum price
+const intent = client.createIntent({
+  maxPricePerRequest: 0.01,
+  capability: 'ai-inference'
+});
+
+// Provider responds with actual price
+const offer = await client.negotiate(endpoint, intent);
+
+// Verify it's within budget
+if (offer.pricePerRequest <= intent.maxPricePerRequest) {
+  // Accept!
+}
+```
+
+### Prepaid Sessions
+```typescript
+// Deposit once, make many requests
+const session = await client.createSession(offer, {
+  depositAmount: 1.0  // 1 USDC
+});
+
+// Make multiple requests without per-request transactions
+await client.executeRequest(session.sessionId, request1);
+await client.executeRequest(session.sessionId, request2);
+await client.executeRequest(session.sessionId, request3);
+```
+
+### Receipt Verification
+```typescript
+const result = await client.executeRequest(sessionId, data);
+
+// Every request gets a cryptographic receipt
+console.log(result.receipt);
+/*
+{
+  receiptId: "receipt_123",
+  inputHash: "sha256(...)",    // Tamper-proof
+  outputHash: "sha256(...)",   // Tamper-proof
+  signature: "...",            // Provider's signature
+  slaVerification: {
+    met: true,
+    metrics: { latency: { expected: 2000, actual: 1234 } }
+  }
+}
+*/
+```
+
+### SLA Enforcement
+```typescript
+// Request SLA guarantees
+const intent = client.createIntent({
+  sla: {
+    maxLatencyMs: 2000,      // Must respond within 2s
+    minUptimePercent: 99.0,  // Must have 99% uptime
+  }
+});
+
+// If provider breaches SLA, automatic refund!
+```
+
+## API Reference
+
+### GistClient
+
+#### Constructor
+```typescript
+new GistClient({
+  connection: Connection,    // Solana connection
+  wallet: Keypair,          // Your wallet
+  httpConfig?: {            // Optional HTTP settings
+    timeout?: number,
+    headers?: Record<string, string>
+  }
+})
+```
+
+#### Methods
+
+**createIntent(options)**
+```typescript
+client.createIntent({
+  capability: string,
+  maxPricePerRequest: number,
+  token: 'SOL' | 'USDC' | 'USDT' | 'BONK',
+  sla?: { maxLatencyMs?, minUptimePercent? },
+  maxSessionBudget?: number,
+  sessionDurationMs?: number,
+  metadata?: Record<string, any>
+})
+```
+
+**negotiate(endpoint, intent)**
+```typescript
+const offer = await client.negotiate(
+  'https://api.provider.com',
+  intent
+);
+```
+
+**createSession(offer, options?)**
+```typescript
+const session = await client.createSession(offer, {
+  depositAmount?: number,      // Custom deposit
+  anchorOnChain?: boolean      // Store on Solana (optional)
+});
+```
+
+**executeRequest(sessionId, data)**
+```typescript
+const result = await client.executeRequest(
+  sessionId,
+  { prompt: 'Hello' }
+);
+// Returns: { data, receipt }
+```
+
+**closeSession(sessionId)**
+```typescript
+const refund = await client.closeSession(sessionId);
+// Returns: { refundAmount, txSignature }
+```
+
+**getSession(sessionId)**
+```typescript
+const session = client.getSession(sessionId);
+```
+
+**getActiveSessions()**
+```typescript
+const sessions = client.getActiveSessions();
+```
+
+## Examples
+
+### AI Inference
+```typescript
+const intent = client.createIntent({
+  capability: 'gpt-4-inference',
+  maxPricePerRequest: 0.01,
+  token: 'USDC'
+});
+
+const offer = await client.negotiate('https://ai-api.com', intent);
+const session = await client.createSession(offer);
+
+const result = await client.executeRequest(session.sessionId, {
+  prompt: 'Write a poem about Solana'
+});
+
+console.log(result.data.text);
+```
+
+### Image Generation
+```typescript
+const intent = client.createIntent({
+  capability: 'image-generation',
+  maxPricePerRequest: 0.05,
+  token: 'USDC'
+});
+
+const offer = await client.negotiate('https://image-api.com', intent);
+const session = await client.createSession(offer);
+
+const result = await client.executeRequest(session.sessionId, {
+  prompt: 'A futuristic city on Mars',
+  style: 'photorealistic'
+});
+
+console.log(result.data.imageUrl);
+```
+
+### Data Analysis
+```typescript
+const intent = client.createIntent({
+  capability: 'data-analysis',
+  maxPricePerRequest: 0.001,
+  token: 'USDC'
+});
+
+const offer = await client.negotiate('https://data-api.com', intent);
+const session = await client.createSession(offer);
+
+const result = await client.executeRequest(session.sessionId, {
+  dataset: myData,
+  operation: 'statistical-summary'
+});
+
+console.log(result.data.analysis);
+```
+
+## Error Handling
+
+```typescript
+try {
+  const offer = await client.negotiate(endpoint, intent);
+  const session = await client.createSession(offer);
+  const result = await client.executeRequest(session.sessionId, data);
+} catch (error) {
+  if (error instanceof InvalidOfferError) {
+    console.error('Offer validation failed');
+  } else if (error instanceof SessionExpiredError) {
+    console.error('Session expired, create new one');
+  } else if (error instanceof InsufficientFundsError) {
+    console.error('Session balance depleted');
+  }
+}
+```
+
+## Related Packages
+
+- **[@gistplus/core](https://www.npmjs.com/package/@gistplus/core)** - Core protocol (auto-installed)
+- **[@gistplus/server](https://www.npmjs.com/package/@gistplus/server)** - For API providers
+
+## License
+
+Apache 2.0
+

package/dist/client.d.ts

@@ -0,0 +1,116 @@
+/**
+ * GistClient - Main client interface for Gist Plus protocol
+ */
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { Intent, Offer, Session, Receipt, SLA, SupportedToken } from '@gistplus/core';
+export interface GistClientConfig {
+    /** Solana connection */
+    connection: Connection;
+    /** Agent's keypair for signing transactions */
+    wallet: Keypair;
+    /** Optional HTTP client config */
+    httpConfig?: {
+        timeout?: number;
+        headers?: Record<string, string>;
+    };
+}
+export interface CreateIntentOptions {
+    capability: string;
+    maxPricePerRequest: number;
+    token: SupportedToken;
+    maxSessionBudget?: number;
+    sessionDurationMs?: number;
+    sla?: SLA;
+    metadata?: Record<string, any>;
+}
+export interface NegotiateOptions {
+    /** Custom headers for the request */
+    headers?: Record<string, string>;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+export interface CreateSessionOptions {
+    /** Custom deposit amount (defaults to maxSessionBudget from Intent) */
+    depositAmount?: number;
+    /** Whether to anchor session on-chain (costs extra transaction fee) */
+    anchorOnChain?: boolean;
+}
+/**
+ * GistClient - Primary interface for Gist Plus protocol
+ *
+ * Enables AI agents to:
+ * 1. Create Intents expressing their needs
+ * 2. Negotiate Offers with providers
+ * 3. Create prepaid Sessions
+ * 4. Execute requests and verify Receipts
+ */
+export declare class GistClient {
+    private connection;
+    private wallet;
+    private httpClient;
+    private sessionManager;
+    constructor(config: GistClientConfig);
+    /**
+     * Create a new Intent
+     */
+    createIntent(options: CreateIntentOptions): Intent;
+    /**
+     * Negotiate an Offer with a provider
+     *
+     * Sends Intent to provider's endpoint and receives a signed Offer.
+     *
+     * @param providerEndpoint - Provider's endpoint URL
+     * @param intent - Intent object
+     * @param options - Negotiation options
+     * @returns Signed Offer from provider
+     */
+    negotiate(providerEndpoint: string, intent: Intent, options?: NegotiateOptions): Promise<Offer>;
+    /**
+     * Create a Session from an accepted Offer
+     *
+     * Transfers funds to the provider and creates a prepaid session.
+     *
+     * @param offer - Accepted Offer
+     * @param options - Session creation options
+     * @returns Active Session
+     */
+    createSession(offer: Offer, options?: CreateSessionOptions): Promise<Session>;
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Execute a request within a Session
+     *
+     * @param sessionId - Session ID
+     * @param requestData - Request payload
+     * @returns Response data and Receipt
+     */
+    executeRequest(sessionId: string, requestData: any): Promise<{
+        data: any;
+        receipt: Receipt;
+    }>;
+    /**
+     * Close a session and claim refund for remaining balance
+     */
+    closeSession(sessionId: string): Promise<{
+        refundAmount: number;
+        txSignature: string;
+    }>;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): Session[];
+    /**
+     * Transfer funds to provider (SOL or SPL token)
+     */
+    private transferFunds;
+    /**
+     * Calculate default deposit amount from Offer
+     */
+    private calculateDefaultDeposit;
+    /**
+     * Get wallet public key
+     */
+    get publicKey(): PublicKey;
+}

package/dist/client.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * GistClient - Main client interface for Gist Plus protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GistClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const core_1 = require("@gistplus/core");
+const http_client_1 = require("./http-client");
+const session_manager_1 = require("./session-manager");
+/**
+ * GistClient - Primary interface for Gist Plus protocol
+ *
+ * Enables AI agents to:
+ * 1. Create Intents expressing their needs
+ * 2. Negotiate Offers with providers
+ * 3. Create prepaid Sessions
+ * 4. Execute requests and verify Receipts
+ */
+class GistClient {
+    constructor(config) {
+        this.connection = config.connection;
+        this.wallet = config.wallet;
+        this.httpClient = new http_client_1.HttpClient(config.httpConfig);
+        this.sessionManager = new session_manager_1.SessionManager(this.connection, this.wallet);
+    }
+    /**
+     * Create a new Intent
+     */
+    createIntent(options) {
+        return (0, core_1.createIntent)({
+            ...options,
+            agentPubkey: this.wallet.publicKey,
+        });
+    }
+    /**
+     * Negotiate an Offer with a provider
+     *
+     * Sends Intent to provider's endpoint and receives a signed Offer.
+     *
+     * @param providerEndpoint - Provider's endpoint URL
+     * @param intent - Intent object
+     * @param options - Negotiation options
+     * @returns Signed Offer from provider
+     */
+    async negotiate(providerEndpoint, intent, options) {
+        // Send Intent to provider
+        const offer = await this.httpClient.sendIntent(providerEndpoint, intent, options);
+        // Verify Offer signature and validity
+        (0, core_1.verifyOffer)(offer);
+        return offer;
+    }
+    /**
+     * Create a Session from an accepted Offer
+     *
+     * Transfers funds to the provider and creates a prepaid session.
+     *
+     * @param offer - Accepted Offer
+     * @param options - Session creation options
+     * @returns Active Session
+     */
+    async createSession(offer, options) {
+        // Calculate deposit amount
+        const depositAmount = options?.depositAmount || this.calculateDefaultDeposit(offer);
+        // Transfer funds to provider
+        const txSignature = await this.transferFunds(offer.providerPubkey, offer.token, depositAmount);
+        // Create session with provider
+        const session = await this.httpClient.createSession(offer, depositAmount, txSignature);
+        // Register session with manager
+        this.sessionManager.registerSession(session);
+        return session;
+    }
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId) {
+        return this.sessionManager.getSession(sessionId);
+    }
+    /**
+     * Execute a request within a Session
+     *
+     * @param sessionId - Session ID
+     * @param requestData - Request payload
+     * @returns Response data and Receipt
+     */
+    async executeRequest(sessionId, requestData) {
+        const session = this.sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Execute request via HTTP client
+        const result = await this.httpClient.executeRequest(session, requestData);
+        // Update session state
+        this.sessionManager.updateSessionAfterRequest(sessionId, result.receipt);
+        return result;
+    }
+    /**
+     * Close a session and claim refund for remaining balance
+     */
+    async closeSession(sessionId) {
+        const session = this.sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Request refund from provider
+        const refundResponse = await this.httpClient.closeSession(session);
+        // Mark session as closed
+        this.sessionManager.closeSession(sessionId);
+        return refundResponse;
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return this.sessionManager.getActiveSessions();
+    }
+    /**
+     * Transfer funds to provider (SOL or SPL token)
+     */
+    async transferFunds(providerPubkey, token, amount) {
+        const provider = new web3_js_1.PublicKey(providerPubkey);
+        if (token === 'SOL') {
+            // Transfer SOL
+            const transaction = new web3_js_1.Transaction().add(web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.wallet.publicKey,
+                toPubkey: provider,
+                lamports: amount * 1e9, // Convert SOL to lamports
+            }));
+            const signature = await (0, web3_js_1.sendAndConfirmTransaction)(this.connection, transaction, [this.wallet]);
+            return signature;
+        }
+        else {
+            // Transfer SPL token
+            const mintAddress = new web3_js_1.PublicKey(core_1.TOKEN_MINTS[token]);
+            // Get or create associated token accounts
+            const fromTokenAccount = await (0, spl_token_1.getOrCreateAssociatedTokenAccount)(this.connection, this.wallet, mintAddress, this.wallet.publicKey);
+            const toTokenAccount = await (0, spl_token_1.getOrCreateAssociatedTokenAccount)(this.connection, this.wallet, mintAddress, provider);
+            // Create transfer instruction
+            const transaction = new web3_js_1.Transaction().add((0, spl_token_1.createTransferInstruction)(fromTokenAccount.address, toTokenAccount.address, this.wallet.publicKey, amount * 1e6, // Assuming 6 decimals for USDC/USDT
+            [], spl_token_1.TOKEN_PROGRAM_ID));
+            const signature = await (0, web3_js_1.sendAndConfirmTransaction)(this.connection, transaction, [this.wallet]);
+            return signature;
+        }
+    }
+    /**
+     * Calculate default deposit amount from Offer
+     */
+    calculateDefaultDeposit(offer) {
+        // Default: enough for 10 requests or session duration worth
+        const minRequests = 10;
+        return offer.pricePerRequest * minRequests;
+    }
+    /**
+     * Get wallet public key
+     */
+    get publicKey() {
+        return this.wallet.publicKey;
+    }
+}
+exports.GistClient = GistClient;

package/dist/http-client.d.ts

@@ -0,0 +1,47 @@
+/**
+ * HTTP Client for Gist Plus protocol communication
+ */
+import { Intent, Offer, Session, Receipt } from '@gistplus/core';
+export interface HttpClientConfig {
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * HttpClient handles HTTP communication with Gist Plus providers
+ */
+export declare class HttpClient {
+    private axios;
+    constructor(config?: HttpClientConfig);
+    /**
+     * Send Intent to provider and receive Offer
+     *
+     * Makes a request to provider endpoint, receives 402 Quote Required,
+     * sends Intent, and receives signed Offer.
+     */
+    sendIntent(endpoint: string, intent: Intent, options?: {
+        headers?: Record<string, string>;
+        timeout?: number;
+    }): Promise<Offer>;
+    /**
+     * Create a Session with provider
+     */
+    createSession(offer: Offer, depositAmount: number, txSignature: string): Promise<Session>;
+    /**
+     * Execute a request within a Session
+     */
+    executeRequest(session: Session, requestData: any): Promise<{
+        data: any;
+        receipt: Receipt;
+    }>;
+    /**
+     * Close a session and request refund
+     */
+    closeSession(session: Session): Promise<{
+        refundAmount: number;
+        txSignature: string;
+    }>;
+    /**
+     * Get provider endpoint for session
+     */
+    private getSessionEndpoint;
+}

package/dist/http-client.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * HTTP Client for Gist Plus protocol communication
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const core_1 = require("@gistplus/core");
+/**
+ * HttpClient handles HTTP communication with Gist Plus providers
+ */
+class HttpClient {
+    constructor(config) {
+        this.axios = axios_1.default.create({
+            timeout: config?.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                ...config?.headers,
+            },
+        });
+    }
+    /**
+     * Send Intent to provider and receive Offer
+     *
+     * Makes a request to provider endpoint, receives 402 Quote Required,
+     * sends Intent, and receives signed Offer.
+     */
+    async sendIntent(endpoint, intent, options) {
+        try {
+            // Send Intent to provider
+            const response = await this.axios.post(endpoint, {}, {
+                headers: {
+                    [core_1.HEADERS.INTENT]: JSON.stringify(intent),
+                    ...options?.headers,
+                },
+                timeout: options?.timeout,
+            });
+            // Provider should respond with Offer in header
+            const offerHeader = response.headers[core_1.HEADERS.OFFER.toLowerCase()];
+            if (!offerHeader) {
+                throw new Error('Provider did not return an Offer');
+            }
+            const offer = JSON.parse(offerHeader);
+            return offer;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response?.status === core_1.HTTP_STATUS.QUOTE_REQUIRED) {
+                // Expected 402 response with Offer
+                const offerHeader = error.response.headers[core_1.HEADERS.OFFER.toLowerCase()];
+                if (offerHeader) {
+                    const offer = JSON.parse(offerHeader);
+                    return offer;
+                }
+            }
+            throw new Error(`Failed to negotiate with provider: ${error}`);
+        }
+    }
+    /**
+     * Create a Session with provider
+     */
+    async createSession(offer, depositAmount, txSignature) {
+        try {
+            const response = await this.axios.post(`${offer.endpoint}/session/create`, {
+                offerId: offer.offerId,
+                depositAmount,
+                txSignature,
+            });
+            if (response.status !== core_1.HTTP_STATUS.SESSION_STARTED && response.status !== 201) {
+                throw new Error(`Unexpected status code: ${response.status}`);
+            }
+            const session = response.data;
+            return session;
+        }
+        catch (error) {
+            throw new Error(`Failed to create session: ${error}`);
+        }
+    }
+    /**
+     * Execute a request within a Session
+     */
+    async executeRequest(session, requestData) {
+        try {
+            // Get provider endpoint from session metadata or construct it
+            const endpoint = this.getSessionEndpoint(session);
+            const response = await this.axios.post(endpoint, requestData, {
+                headers: {
+                    [core_1.HEADERS.SESSION_ID]: session.sessionId,
+                },
+            });
+            // Extract receipt from header
+            const receiptHeader = response.headers[core_1.HEADERS.RECEIPT.toLowerCase()];
+            if (!receiptHeader) {
+                throw new Error('Provider did not return a Receipt');
+            }
+            const receipt = JSON.parse(receiptHeader);
+            // Verify receipt signature
+            (0, core_1.verifyReceipt)(receipt);
+            return {
+                data: response.data,
+                receipt,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to execute request: ${error}`);
+        }
+    }
+    /**
+     * Close a session and request refund
+     */
+    async closeSession(session) {
+        try {
+            const endpoint = this.getSessionEndpoint(session);
+            const response = await this.axios.post(`${endpoint}/close`, {
+                sessionId: session.sessionId,
+            }, {
+                headers: {
+                    [core_1.HEADERS.SESSION_ID]: session.sessionId,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to close session: ${error}`);
+        }
+    }
+    /**
+     * Get provider endpoint for session
+     */
+    getSessionEndpoint(session) {
+        // In a real implementation, this might be stored in session metadata
+        // For now, construct from provider's base endpoint
+        return session.metadata?.endpoint || `https://provider/${session.providerPubkey}`;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @gistplus/client
+ *
+ * Client SDK for AI agents and applications to interact with Gist Plus providers.
+ * Handles Intent creation, Offer negotiation, Session management, and Receipt verification.
+ */
+export * from './client';
+export * from './http-client';
+export * from './session-manager';
+export { Intent, Offer, Session, Receipt, SLA, SessionState, createIntent, verifyOffer, verifyReceipt, SUPPORTED_TOKENS, SupportedToken, } from '@gistplus/core';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @gistplus/client
+ *
+ * Client SDK for AI agents and applications to interact with Gist Plus providers.
+ * Handles Intent creation, Offer negotiation, Session management, and Receipt verification.
+ */
+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 });
+exports.SUPPORTED_TOKENS = exports.verifyReceipt = exports.verifyOffer = exports.createIntent = exports.SessionState = void 0;
+__exportStar(require("./client"), exports);
+__exportStar(require("./http-client"), exports);
+__exportStar(require("./session-manager"), exports);
+// Re-export core types for convenience
+var core_1 = require("@gistplus/core");
+Object.defineProperty(exports, "SessionState", { enumerable: true, get: function () { return core_1.SessionState; } });
+Object.defineProperty(exports, "createIntent", { enumerable: true, get: function () { return core_1.createIntent; } });
+Object.defineProperty(exports, "verifyOffer", { enumerable: true, get: function () { return core_1.verifyOffer; } });
+Object.defineProperty(exports, "verifyReceipt", { enumerable: true, get: function () { return core_1.verifyReceipt; } });
+Object.defineProperty(exports, "SUPPORTED_TOKENS", { enumerable: true, get: function () { return core_1.SUPPORTED_TOKENS; } });

package/dist/session-manager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SessionManager - Manages active sessions and their state
+ */
+import { Connection, Keypair } from '@solana/web3.js';
+import { Session, Receipt } from '@gistplus/core';
+/**
+ * SessionManager tracks and manages active Gist Plus sessions
+ */
+export declare class SessionManager {
+    private sessions;
+    private connection;
+    private wallet;
+    constructor(connection: Connection, wallet: Keypair);
+    /**
+     * Register a new session
+     */
+    registerSession(session: Session): void;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Update session after a request is completed
+     */
+    updateSessionAfterRequest(sessionId: string, receipt: Receipt): void;
+    /**
+     * Close a session
+     */
+    closeSession(sessionId: string): void;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): Session[];
+    /**
+     * Get all sessions
+     */
+    getAllSessions(): Session[];
+    /**
+     * Clean up expired sessions
+     */
+    private cleanup;
+    /**
+     * Start background cleanup task
+     */
+    private startCleanupTask;
+    /**
+     * Get session count
+     */
+    getSessionCount(): number;
+}

package/dist/session-manager.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * SessionManager - Manages active sessions and their state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const core_1 = require("@gistplus/core");
+/**
+ * SessionManager tracks and manages active Gist Plus sessions
+ */
+class SessionManager {
+    constructor(connection, wallet) {
+        this.sessions = new Map();
+        this.connection = connection;
+        this.wallet = wallet;
+        // Start background cleanup task
+        this.startCleanupTask();
+    }
+    /**
+     * Register a new session
+     */
+    registerSession(session) {
+        this.sessions.set(session.sessionId, session);
+    }
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        // Check if session has expired and update state
+        if (!(0, core_1.isSessionActive)(session) && session.state === core_1.SessionState.ACTIVE) {
+            const expiredSession = (0, core_1.expireSession)(session);
+            this.sessions.set(sessionId, expiredSession);
+            return expiredSession;
+        }
+        return session;
+    }
+    /**
+     * Update session after a request is completed
+     */
+    updateSessionAfterRequest(sessionId, receipt) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Deduct amount from session
+        const updatedSession = (0, core_1.deductFromSession)(session, receipt.amountCharged);
+        this.sessions.set(sessionId, updatedSession);
+    }
+    /**
+     * Close a session
+     */
+    closeSession(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        const activeSessions = [];
+        for (const session of this.sessions.values()) {
+            if ((0, core_1.isSessionActive)(session)) {
+                activeSessions.push(session);
+            }
+        }
+        return activeSessions;
+    }
+    /**
+     * Get all sessions
+     */
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    /**
+     * Clean up expired sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [sessionId, session] of this.sessions.entries()) {
+            if (session.state === core_1.SessionState.EXPIRED || now > session.expiresAt) {
+                // Keep expired sessions for a grace period (1 hour)
+                if (now > session.expiresAt + 3600000) {
+                    this.sessions.delete(sessionId);
+                }
+            }
+        }
+    }
+    /**
+     * Start background cleanup task
+     */
+    startCleanupTask() {
+        // Clean up every 5 minutes
+        setInterval(() => {
+            this.cleanup();
+        }, 300000);
+    }
+    /**
+     * Get session count
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}
+exports.SessionManager = SessionManager;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gistplus/client",
+  "version": "0.1.0",
+  "description": "Client SDK for Gist Plus - enables agents and applications to negotiate, transact, and verify with providers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "gistplus",
+    "gist",
+    "client",
+    "solana",
+    "ai-agents",
+    "payments"
+  ],
+  "author": "Gist Plus",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gistplus/gistplus"
+  },
+  "homepage": "https://github.com/gistplus/gistplus#readme",
+  "bugs": {
+    "url": "https://github.com/gistplus/gistplus/issues"
+  },
+  "dependencies": {
+    "@gistplus/core": "^0.1.0",
+    "@solana/web3.js": "^1.87.6",
+    "@solana/spl-token": "^0.3.9",
+    "axios": "^1.6.5"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.6",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.11",
+    "rimraf": "^5.0.5"
+  }
+}