1// anthropic.service.ts2import { Injectable, signal } from '@angular/core';3 4@Injectable({ providedIn: 'root' })5export class AnthropicService {6  private apiUrl = '/api/anthropic';7  private streamingContent = signal('');8  readonly streamingContent$ = this.streamingContent.asReadonly();9 10  async streamChat(messages: { role: string; content: string }[]): Promise<string> {11    this.streamingContent.set('');12 13    const response = await fetch(this.apiUrl, {14      method: 'POST',15      headers: { 'Content-Type': 'application/json' },16      body: JSON.stringify({17        model: 'claude-3-opus-20240229',18        messages,19        max_tokens: 4096,20        stream: true,21      }),22    });23 24    const reader = response.body?.getReader();25    const decoder = new TextDecoder();26    let fullContent = '';27 28    if (!reader) throw new Error('No response body');29 30    while (true) {31      const { done, value } = await reader.read();32      if (done) break;33 34      const chunk = decoder.decode(value);35      const lines = chunk.split('\n');36 37      for (const line of lines) {38        if (line.startsWith('data: ')) {39          try {40            const data = JSON.parse(line.slice(6));41            if (data.type === 'content_block_delta') {42              const content = data.delta?.text || '';43              fullContent += content;44              this.streamingContent.set(fullContent);45            }46          } catch {47            // Skip invalid JSON48          }49        }50      }51    }52 53    this.streamingContent.set('');54    return fullContent;55  }56}

1// chat.service.ts (with error handling)2import { Injectable, signal } from '@angular/core';3 4export interface ChatError {5  code: 'NETWORK' | 'RATE_LIMIT' | 'AUTH' | 'SERVER' | 'UNKNOWN';6  message: string;7  retryable: boolean;8}9 10@Injectable({ providedIn: 'root' })11export class ChatService {12  private error = signal<ChatError | null>(null);13  readonly error$ = this.error.asReadonly();14 15  async sendMessage(content: string): Promise<string> {16    this.error.set(null);17 18    try {19      const response = await fetch('/api/chat', {20        method: 'POST',21        headers: { 'Content-Type': 'application/json' },22        body: JSON.stringify({ messages: [{ role: 'user', content }] }),23      });24 25      if (!response.ok) {26        const error = await this.handleHttpError(response);27        this.error.set(error);28        throw new Error(error.message);29      }30 31      return await response.text();32    } catch (err) {33      if (err instanceof TypeError) {34        // Network error35        this.error.set({36          code: 'NETWORK',37          message: 'Unable to connect. Check your internet connection.',38          retryable: true,39        });40      }41      throw err;42    }43  }44 45  private async handleHttpError(response: Response): Promise<ChatError> {46    switch (response.status) {47      case 401:48        return {49          code: 'AUTH',50          message: 'Authentication failed. Please check your API key.',51          retryable: false,52        };53      case 429:54        return {55          code: 'RATE_LIMIT',56          message: 'Rate limit exceeded. Please wait a moment.',57          retryable: true,58        };59      case 500:60      case 502:61      case 503:62        return {63          code: 'SERVER',64          message: 'Server error. Please try again later.',65          retryable: true,66        };67      default:68        return {69          code: 'UNKNOWN',70          message: `Error: ${response.statusText}`,71          retryable: false,72        };73    }74  }75}76 77// Usage in component78@Component({79  template: `80    @if (error(); as err) {81      <div class="rounded-lg bg-destructive/10 p-4 text-destructive">82        <p>{{ err.message }}</p>83        @if (err.retryable) {84          <button (click)="retry()">Retry</button>85        }86      </div>87    }88  `,89})90export class ChatComponent {91  private chatService = inject(ChatService);92  error = this.chatService.error$;93 94  retry() {95    // Resend last message96  }97}

1// rate-limiter.service.ts2import { Injectable, signal } from '@angular/core';3 4@Injectable({ providedIn: 'root' })5export class RateLimiterService {6  private requestTimes: number[] = [];7  private readonly maxRequests = 10; // per minute8  private readonly windowMs = 60000;9 10  private isLimited = signal(false);11  readonly isLimited$ = this.isLimited.asReadonly();12 13  canMakeRequest(): boolean {14    const now = Date.now();15 16    // Remove old requests outside the window17    this.requestTimes = this.requestTimes.filter(18      time => now - time < this.windowMs19    );20 21    if (this.requestTimes.length >= this.maxRequests) {22      this.isLimited.set(true);23 24      // Calculate time until oldest request expires25      const oldestRequest = this.requestTimes[0];26      const resetTime = oldestRequest + this.windowMs - now;27 28      setTimeout(() => this.isLimited.set(false), resetTime);29      return false;30    }31 32    return true;33  }34 35  recordRequest() {36    this.requestTimes.push(Date.now());37  }38 39  getRemainingRequests(): number {40    const now = Date.now();41    const recentRequests = this.requestTimes.filter(42      time => now - time < this.windowMs43    );44    return Math.max(0, this.maxRequests - recentRequests.length);45  }46}47 48// Usage49async sendMessage(content: string) {50  if (!this.rateLimiter.canMakeRequest()) {51    this.error.set('Rate limited. Please wait.');52    return;53  }54 55  this.rateLimiter.recordRequest();56  // Make API call57}

1// retry.util.ts2export async function withRetry<T>(3  fn: () => Promise<T>,4  options: {5    maxRetries?: number;6    baseDelay?: number;7    maxDelay?: number;8    shouldRetry?: (error: Error) => boolean;9  } = {}10): Promise<T> {11  const {12    maxRetries = 3,13    baseDelay = 1000,14    maxDelay = 10000,15    shouldRetry = () => true,16  } = options;17 18  let lastError: Error;19 20  for (let attempt = 0; attempt <= maxRetries; attempt++) {21    try {22      return await fn();23    } catch (error) {24      lastError = error as Error;25 26      if (attempt === maxRetries || !shouldRetry(lastError)) {27        throw lastError;28      }29 30      // Exponential backoff with jitter31      const delay = Math.min(32        baseDelay * Math.pow(2, attempt) + Math.random() * 1000,33        maxDelay34      );35 36      await new Promise(resolve => setTimeout(resolve, delay));37    }38  }39 40  throw lastError!;41}42 43// Usage44const response = await withRetry(45  () => this.chatService.sendMessage(content),46  {47    maxRetries: 3,48    shouldRetry: (error) => {49      // Only retry on network or 5xx errors50      return error.message.includes('network') ||51             error.message.includes('5');52    },53  }54);

1// token-counter.service.ts2import { Injectable } from '@angular/core';3 4@Injectable({ providedIn: 'root' })5export class TokenCounterService {6  // Approximate token count (actual count requires tiktoken library)7  estimateTokens(text: string): number {8    // Rough estimate: ~4 characters per token for English9    return Math.ceil(text.length / 4);10  }11 12  // For accurate counting, use tiktoken13  // npm install @dqbd/tiktoken14  /*15  import { encoding_for_model } from '@dqbd/tiktoken';16 17  countTokensAccurate(text: string, model = 'gpt-4'): number {18    const enc = encoding_for_model(model);19    const tokens = enc.encode(text);20    enc.free();21    return tokens.length;22  }23  */24 25  // Check if within context limit26  isWithinLimit(27    messages: { content: string }[],28    maxTokens: number29  ): boolean {30    const totalTokens = messages.reduce(31      (sum, msg) => sum + this.estimateTokens(msg.content),32      033    );34    return totalTokens < maxTokens;35  }36 37  // Truncate messages to fit context38  truncateMessages(39    messages: { content: string }[],40    maxTokens: number41  ): { content: string }[] {42    const result: { content: string }[] = [];43    let currentTokens = 0;44 45    // Keep most recent messages46    for (let i = messages.length - 1; i >= 0; i--) {47      const tokens = this.estimateTokens(messages[i].content);48      if (currentTokens + tokens > maxTokens) break;49      result.unshift(messages[i]);50      currentTokens += tokens;51    }52 53    return result;54  }55}