@pingagent/sdk 0.1.7 → 0.1.9

package/src/a2a-adapter.ts

@@ -1,159 +0,0 @@
-/**
- * A2A adapter for PingAgentClient.
- * Allows PingAgent to call external agents that speak the A2A protocol,
- * translating PingAgent's task model to A2A's message/send + tasks/get.
- */
-
-import {
-  A2AClient,
-  A2AClientError,
-  type A2AClientOptions,
-  type AgentCard,
-  type Task as A2ATask,
-  type SendMessageResult,
-  type TextPart,
-  type DataPart,
-  type Part,
-  type Message as A2AMessage,
-} from '@pingagent/a2a';
-
-export interface A2AAdapterOptions {
-  agentUrl: string;
-  authToken?: string;
-  timeoutMs?: number;
-}
-
-/**
- * Wraps an A2AClient and exposes PingAgent-style operations that delegate
- * to an external A2A agent.
- */
-export class A2AAdapter {
-  private client: A2AClient;
-  private cachedCard: AgentCard | null = null;
-
-  constructor(opts: A2AAdapterOptions) {
-    this.client = new A2AClient({
-      agentUrl: opts.agentUrl,
-      authToken: opts.authToken ? `Bearer ${opts.authToken}` : undefined,
-      timeoutMs: opts.timeoutMs,
-    });
-  }
-
-  async getAgentCard(): Promise<AgentCard> {
-    if (!this.cachedCard) {
-      this.cachedCard = await this.client.fetchAgentCard();
-    }
-    return this.cachedCard;
-  }
-
-  /**
-   * Send a task to the external A2A agent and optionally wait for completion.
-   */
-  async sendTask(opts: {
-    title: string;
-    description?: string;
-    input?: unknown;
-    wait?: boolean;
-    timeoutMs?: number;
-  }): Promise<A2ATaskResult> {
-    const parts: Part[] = [];
-    parts.push({ kind: 'text', text: opts.title } as TextPart);
-    if (opts.description) {
-      parts.push({ kind: 'text', text: opts.description } as TextPart);
-    }
-    if (opts.input) {
-      parts.push({
-        kind: 'data',
-        data: typeof opts.input === 'object'
-          ? (opts.input as Record<string, unknown>)
-          : { value: opts.input },
-      } as DataPart);
-    }
-
-    const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const message: A2AMessage = {
-      kind: 'message',
-      messageId,
-      role: 'user',
-      parts,
-    };
-
-    if (opts.wait) {
-      const task = await this.client.sendAndWait(
-        { message, configuration: { blocking: true } },
-        { maxPollMs: opts.timeoutMs ?? 120_000 },
-      );
-      return this.convertTask(task);
-    }
-
-    const result = await this.client.sendMessage({ message });
-    if (result.kind === 'task') {
-      return this.convertTask(result);
-    }
-    return {
-      taskId: result.messageId,
-      state: 'completed' as const,
-      summary: this.extractText(result.parts),
-    };
-  }
-
-  async getTaskStatus(taskId: string): Promise<A2ATaskResult> {
-    const task = await this.client.getTask(taskId);
-    return this.convertTask(task);
-  }
-
-  async cancelTask(taskId: string): Promise<A2ATaskResult> {
-    const task = await this.client.cancelTask(taskId);
-    return this.convertTask(task);
-  }
-
-  async sendText(text: string, opts?: { blocking?: boolean }): Promise<A2ATaskResult> {
-    const result = await this.client.sendText(text, { blocking: opts?.blocking });
-    if (result.kind === 'task') {
-      return this.convertTask(result);
-    }
-    return {
-      taskId: result.messageId,
-      state: 'completed',
-      summary: this.extractText(result.parts),
-    };
-  }
-
-  private convertTask(task: A2ATask): A2ATaskResult {
-    const summary = task.artifacts
-      ?.flatMap((a) => a.parts)
-      .filter((p): p is TextPart => p.kind === 'text')
-      .map((p) => p.text)
-      .join('\n');
-
-    const output = task.artifacts
-      ?.flatMap((a) => a.parts)
-      .filter((p): p is DataPart => p.kind === 'data')
-      .map((p) => p.data);
-
-    return {
-      taskId: task.id,
-      contextId: task.contextId,
-      state: task.status.state,
-      summary: summary || undefined,
-      output: output && output.length > 0 ? (output.length === 1 ? output[0] : output) : undefined,
-      timestamp: task.status.timestamp,
-    };
-  }
-
-  private extractText(parts: Part[]): string | undefined {
-    return parts
-      .filter((p): p is TextPart => p.kind === 'text')
-      .map((p) => p.text)
-      .join('\n') || undefined;
-  }
-}
-
-export interface A2ATaskResult {
-  taskId: string;
-  contextId?: string;
-  state: string;
-  summary?: string;
-  output?: unknown;
-  timestamp?: string;
-}

package/src/auth.ts

@@ -1,50 +0,0 @@
-/**
- * Proactive token refresh: call before creating the client when token is near or past expiry.
- * Server allows refresh only within a short grace period (default 5 min) after expiry.
- */
-
-import { loadIdentity, updateStoredToken, identityExists } from './identity.js';
-
-const REFRESH_GRACE_MS = 5 * 60 * 1000; // 5 minutes, must match server's verifyTokenWithGrace
-
-/**
- * If the stored token is expired or expires within the refresh grace window,
- * call the server's /v1/auth/refresh and persist the new token.
- * Call this after loadIdentity() and before creating PingAgentClient.
- * @returns true if a refresh was performed and the identity file was updated, false otherwise
- */
-export async function ensureTokenValid(
-  identityPath?: string,
-  serverUrl?: string,
-): Promise<boolean> {
-  if (!identityExists(identityPath)) return false;
-  const id = loadIdentity(identityPath);
-  const token = id.accessToken;
-  const expiresAt = id.tokenExpiresAt;
-  if (!token || expiresAt == null) return false;
-
-  const now = Date.now();
-  if (expiresAt > now + REFRESH_GRACE_MS) return false; // still valid, no need to refresh
-
-  const baseUrl = (serverUrl ?? id.serverUrl ?? 'https://pingagent.chat').replace(/\/$/, '');
-  try {
-    const res = await fetch(`${baseUrl}/v1/auth/refresh`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ access_token: token }),
-    });
-    const text = await res.text();
-    let data: { ok?: boolean; data?: { access_token?: string; expires_ms?: number } };
-    try {
-      data = text ? JSON.parse(text) : {};
-    } catch {
-      return false;
-    }
-    if (!res.ok || !data.ok || !data.data?.access_token || data.data.expires_ms == null) return false;
-    const newExpiresAt = now + data.data.expires_ms;
-    updateStoredToken(data.data.access_token, newExpiresAt, identityPath);
-    return true;
-  } catch {
-    return false;
-  }
-}