Conversation History

import { Pinecall, JsonFileHistory } from "@pinecall/sdk";

const history = new JsonFileHistory("./data/calls.json");

const pc = new Pinecall({ apiKey: process.env.PINECALL_API_KEY! });
await pc.connect();

const agent = pc.agent("my-agent", {
  llm: "openai/gpt-4.1-mini",
  voice: "elevenlabs/sarah",
  stt: "deepgram/flux",
  prompt: "You are a helpful assistant with memory of past conversations.",
  phoneNumber: "+13186330963",
  history, // ← auto-saves AND auto-restores
});

agent.on("call.started", (call) => {
  call.say("Hello! How can I help?");
});

call.ended → HistoryStore.save({
    callId, agentId, channel, direction,
    from, to, startedAt, endedAt, duration,
    reason, transcript, messages, metadata
})

agent.on("call.started", async (call) => {
  // Custom: only restore if the last call was within 24 hours
  const prior = await history.findByContact(call.from, 1);
  if (prior.length > 0 && Date.now() / 1000 - prior[0].endedAt < 86400) {
    await call.setHistory(prior[0].messages);
  }
});

// Browser-side: pass userId when getting a token
const token = await fetch("/api/token", {
  body: JSON.stringify({ userId: "user-123" }),
});

agent.on("call.started", async (call) => {
  const contactId = call.from !== "webrtc"
    ? call.from                          // Phone number
    : call.metadata?.userId              // WebRTC/Chat userId
      ? String(call.metadata.userId)
      : null;

  if (contactId) {
    const prior = await history.findByContact(contactId, 1);
    if (prior.length > 0) {
      await call.setHistory(prior[0].messages);
    }
  }
});

agent.on("whatsapp.sessionEnded", (event) => {
  console.log(`WhatsApp session ended: ${event.contactPhone} (${event.reason})`);
  // Already auto-saved by HistoryStore — no manual save needed
});

agent.on("whatsapp.sessionStarted", async (session) => {
  const prior = await history.findByContact(session.contactPhone, 1);
  if (prior.length > 0) {
    await session.setHistory(prior[0].messages);
  }
});

import { JsonFileHistory } from "@pinecall/sdk";

const history = new JsonFileHistory("./data/calls.json");

interface HistoryStore {
  // Required — called automatically on call.ended
  save(record: ConversationRecord): Promise<void>;

  // Optional — for restoring prior conversations
  findByContact?(contactId: string, limit?: number): Promise<ConversationRecord[]>;

  // Optional — for admin/dashboard features
  list?(agentId: string, limit?: number): Promise<ConversationRecord[]>;
  get?(callId: string): Promise<ConversationRecord | null>;
  delete?(callId: string): Promise<boolean>;
}

import type { HistoryStore, ConversationRecord } from "@pinecall/sdk";
import { MongoClient } from "mongodb";

const client = new MongoClient(process.env.MONGODB_URI!);
const db = client.db("myapp");
const conversations = db.collection<ConversationRecord>("conversations");

class MongoHistory implements HistoryStore {
  async save(record: ConversationRecord): Promise<void> {
    await conversations.updateOne(
      { callId: record.callId },
      { $set: record },
      { upsert: true },
    );
  }

  async findByContact(contactId: string, limit = 5): Promise<ConversationRecord[]> {
    return conversations
      .find({ from: contactId })
      .sort({ endedAt: -1 })
      .limit(limit)
      .toArray();
  }

  async list(agentId: string, limit = 50): Promise<ConversationRecord[]> {
    return conversations
      .find({ agentId })
      .sort({ endedAt: -1 })
      .limit(limit)
      .toArray();
  }

  async get(callId: string): Promise<ConversationRecord | null> {
    return conversations.findOne({ callId });
  }

  async delete(callId: string): Promise<boolean> {
    const result = await conversations.deleteOne({ callId });
    return result.deletedCount > 0;
  }
}

// Usage
const agent = pc.agent("my-agent", {
  history: new MongoHistory(),
});

import type { HistoryStore, ConversationRecord } from "@pinecall/sdk";
import pg from "pg";

const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });

class PostgresHistory implements HistoryStore {
  async save(record: ConversationRecord): Promise<void> {
    await pool.query(
      `INSERT INTO conversations (call_id, agent_id, channel, direction, caller, callee,
        started_at, ended_at, duration, reason, transcript, messages, metadata)
       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
       ON CONFLICT (call_id) DO UPDATE SET
        transcript = $11, messages = $12, ended_at = $8, duration = $9`,
      [
        record.callId, record.agentId, record.channel, record.direction,
        record.from, record.to, record.startedAt, record.endedAt,
        record.duration, record.reason,
        JSON.stringify(record.transcript),
        JSON.stringify(record.messages),
        JSON.stringify(record.metadata),
      ],
    );
  }

  async findByContact(contactId: string, limit = 5): Promise<ConversationRecord[]> {
    const { rows } = await pool.query(
      `SELECT * FROM conversations WHERE caller = $1 ORDER BY ended_at DESC LIMIT $2`,
      [contactId, limit],
    );
    return rows.map(this.#fromRow);
  }

  #fromRow(row: any): ConversationRecord {
    return {
      callId: row.call_id,
      agentId: row.agent_id,
      channel: row.channel,
      direction: row.direction,
      from: row.caller,
      to: row.callee,
      startedAt: row.started_at,
      endedAt: row.ended_at,
      duration: row.duration,
      reason: row.reason,
      transcript: row.transcript,
      messages: row.messages,
      metadata: row.metadata,
    };
  }
}

import type { HistoryStore, ConversationRecord } from "@pinecall/sdk";

class APIHistory implements HistoryStore {
  constructor(private baseUrl: string, private token: string) {}

  async save(record: ConversationRecord): Promise<void> {
    await fetch(`${this.baseUrl}/conversations`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${this.token}`,
      },
      body: JSON.stringify(record),
    });
  }

  async findByContact(contactId: string, limit = 5): Promise<ConversationRecord[]> {
    const res = await fetch(
      `${this.baseUrl}/conversations?from=${encodeURIComponent(contactId)}&limit=${limit}`,
      { headers: { Authorization: `Bearer ${this.token}` } },
    );
    return res.json();
  }
}