Skip to main content 홈 크리에이터 jeremylongshore claude-code-plugins-plus-skills twinmind-rate-limits
twinmind-rate-limits Implement TwinMind rate limiting, backoff, and optimization patterns.
Use when handling rate limit errors, implementing retry logic,
or optimizing API request throughput for TwinMind.
Trigger with phrases like "twinmind rate limit", "twinmind throttling",
"twinmind 429", "twinmind retry", "twinmind backoff".
설치로 이동 Skills Marketplace 커뮤니티가 만든 AI 스킬을 발견하고 탐색하세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/jeremylongshore/claude-code-plugins-plus-skills --skill twinmind-rate-limits명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Zip 다운로드 다운로드 중... 이 저장소의 다른 Skills Implement user sign-up and sign-in flows with Clerk.
Use when building authentication UI, customizing sign-in experience,
or implementing OAuth social login.
Trigger with phrases like "clerk sign-in", "clerk sign-up",
"clerk login flow", "clerk OAuth", "clerk social login".
Implement session management and middleware with Clerk.
Use when managing user sessions, configuring route protection,
or implementing token refresh and custom JWT templates.
Trigger with phrases like "clerk session", "clerk middleware",
"clerk route protection", "clerk token", "clerk JWT".
Configure enterprise SSO, role-based access control, and organization management.
Use when implementing SSO integration, configuring role-based permissions,
or setting up organization-level controls.
Trigger with phrases like "clerk SSO", "clerk RBAC",
"clerk enterprise", "clerk roles", "clerk permissions", "clerk organizations".
jeremylongshore
jeremylongshore/claude-code-plugins-plus-skills
GitHub 저장소 열기 name twinmind-rate-limits description Implement TwinMind rate limiting, backoff, and optimization patterns.
Use when handling rate limit errors, implementing retry logic,
or optimizing API request throughput for TwinMind.
Trigger with phrases like "twinmind rate limit", "twinmind throttling",
"twinmind 429", "twinmind retry", "twinmind backoff".
allowed-tools Read, Write, Edit version 1.13.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","twinmind","api"] compatibility Designed for Claude Code, also compatible with Codex and OpenClaw
TwinMind Rate Limits
Overview
Handle TwinMind rate limits gracefully with exponential backoff and request optimization.
Prerequisites
TwinMind API access (Pro/Enterprise)
Understanding of async/await patterns
Familiarity with rate limiting concepts
Instructions
Step 1: Understand Rate Limit Tiers
Tier Audio Hours/Month API Requests/Min Concurrent Transcriptions Burst Free Unlimited 30 1 5 Pro ($10/mo) Unlimited 60 3 15 Enterprise Unlimited 300 10 50
Key Limits:
Transcription: Based on audio duration ($0.23/hour with Ear-3)
AI Operations: Token-based (2M context for Pro)
Summarization: 10/minute (Free), 30/minute (Pro)
Memory Search: 60/minute (Free), 300/minute (Pro)
Step 2: Implement Exponential Backoff with Jitter
interface RateLimitConfig {
maxRetries : number ;
baseDelayMs : number ;
maxDelayMs : number ;
jitterMs : number ;
}
const defaultConfig : RateLimitConfig = {
maxRetries : 5 ,
baseDelayMs : 1000 , # 1000 : 1 second in ms
maxDelayMs : 60000 ,
jitterMs : 500
HTTP
500
Internal
Server
Error
export
async
function
operation
() =>
Promise
config
Partial
RateLimitConfig
Promise
const
for
let
0
try
return
await
operation
catch
error
any
if
throw
const
response
status
if
429
503
throw
const
response
headers
'retry-after'
let
delay
number
if
parseInt
1000
1
in
else
const
Math
pow
2
const
Math
random
Math
min
console
log
`Rate limited (attempt ${attempt + 1 } ). Waiting ${delay} ms...`
await
new
Promise
r =>
setTimeout
throw
new
Error
'Max retries exceeded'
Step 3: Implement Request Queue
import PQueue from 'p-queue' ;
interface QueueConfig {
concurrency : number ;
intervalMs : number ;
intervalCap : number ;
}
const tierConfigs : Record <string , QueueConfig > = {
free : { concurrency : 1 , intervalMs : 60000 , intervalCap : 30 }, # 60000 : 1 minute in ms
pro : { concurrency : 3 , intervalMs : 60000 , intervalCap : 60 }, # 1 minute in ms
enterprise : { concurrency : 10 , intervalMs : 60000 , intervalCap : 300 }, # 300 : 1 minute in ms
};
export class TwinMindQueue {
private queue : PQueue ;
private tier : string ;
constructor (tier : 'free' | 'pro' | 'enterprise' = 'pro' const config = tierConfigs[tier];
this .tier = tier;
this .queue = new PQueue ({
concurrency : config.concurrency ,
interval : config.intervalMs ,
intervalCap : config.intervalCap ,
});
}
async add<T>(operation : () => Promise <T>, priority ?: number ): Promise <T> {
return this .queue .add (operation, { priority }) as Promise <T>;
}
get pending (): number {
return this .queue .pending ;
}
get size (): number {
return this .queue .size ;
}
pause (): void {
this .queue .pause ();
}
resume (): void {
this .queue .start ();
}
clear (): void {
this .queue .clear ();
}
}
let queueInstance : TwinMindQueue | null = null ;
export function getQueue (tier ?: 'free' | 'pro' | 'enterprise' TwinMindQueue {
if (!queueInstance) {
queueInstance = new TwinMindQueue (tier);
}
return queueInstance;
}
Step 4: Monitor Rate Limit Headers
export interface RateLimitStatus {
limit : number ;
remaining : number ;
reset : Date ;
percentUsed : number ;
}
export class RateLimitMonitor {
private limits = new Map <string , RateLimitStatus >();
updateFromResponse (endpoint : string , headers : Headers ): void {
const limit = parseInt (headers.get ('X-RateLimit-Limit' ) || '60' );
const remaining = parseInt (headers.get ('X-RateLimit-Remaining' ) || '60' );
const resetTimestamp = headers.get ('X-RateLimit-Reset' );
const reset = resetTimestamp
? new Date (parseInt (resetTimestamp) * 1000 ) # 1000 : 1 second in ms
: new Date (Date .now () + 60000 ); # 60000 : 1 minute in ms
this .limits .set (endpoint, {
limit,
remaining,
reset,
percentUsed : ((limit - remaining) / limit) * 100 ,
});
}
getStatus (endpoint : string ): RateLimitStatus | undefined {
return this .limits .get (endpoint);
}
shouldThrottle (endpoint : string , threshold = 10 ): boolean {
const status = this .limits .get (endpoint);
if (!status) return false ;
return status.remaining < threshold && new Date () < status.reset ;
}
getWaitTime (endpoint : string ): number {
const status = this .limits .get (endpoint);
if (!status) return 0 ;
const now = Date .now ();
const resetTime = status.reset .getTime ();
return Math .max (0 , resetTime - now);
}
getAllStatuses (): Map <string , RateLimitStatus > {
return new Map (this .limits );
}
}
export const rateLimitMonitor = new RateLimitMonitor ();
Step 5: Implement Adaptive Rate Limiting
export class AdaptiveRateLimiter {
private successCount = 0 ;
private failureCount = 0 ;
private currentDelay = 0 ;
private minDelay = 0 ;
private maxDelay = 5000 ; # 5000 : 5 seconds in ms
private windowMs = 60000 ; # 60000 : 1 minute in ms
private windowStart = Date .now ();
recordSuccess (): void {
this .maybeResetWindow ();
this .successCount ++;
if (this .currentDelay > 0 ) {
this .currentDelay = Math .max (0 , this .currentDelay - 100 );
}
}
recordFailure (isRateLimit : boolean ): void {
this .maybeResetWindow ();
this .failureCount ++;
if (isRateLimit) {
this .currentDelay = Math .min (this .maxDelay , this .currentDelay + 500 ); # HTTP 500 Internal Server Error
}
}
private maybeResetWindow (): void {
const now = Date .now ();
if (now - this .windowStart > this .windowMs ) {
this .successCount = 0 ;
this .failureCount = 0 ;
this .windowStart = now;
}
}
getDelay (): number {
return this .currentDelay ;
}
getMetrics (): { success : number ; failure : number ; delay : number ; ratio : number } {
const total = this .successCount + this .failureCount ;
return {
success : this .successCount ,
failure : this .failureCount ,
delay : this .currentDelay ,
ratio : total > 0 ? this .successCount / total : 1 ,
};
}
async wait (): Promise <void > {
if (this .currentDelay > 0 ) {
await new Promise (r =>setTimeout (r, this .currentDelay ));
}
}
}
Step 6: Batch Requests for Efficiency
export interface BatchOptions {
maxBatchSize : number ;
maxWaitMs : number ;
}
export class TranscriptionBatcher {
private pending : Array <{
audioUrl : string ;
resolve : (value : any void ;
reject : (error : any void ;
}> = [];
private timer : NodeJS .Timeout | null = null ;
private options : BatchOptions ;
constructor (options : Partial <BatchOptions > = {}this .options = {
maxBatchSize : 5 ,
maxWaitMs : 1000 , # 1000 : 1 second in ms
...options,
};
}
async transcribe (audioUrl : string ): Promise <any > {
return new Promise ((resolve, reject ) => {
this .pending .push ({ audioUrl, resolve, reject });
if (this .pending .length >= this .options .maxBatchSize ) {
this .flush ();
} else if (!this .timer ) {
this .timer = setTimeout (() => this .flush (), this .options .maxWaitMs );
}
});
}
private async flush (): Promise <void > {
if (this .timer ) {
clearTimeout (this .timer );
this .timer = null ;
}
const batch = this .pending .splice (0 , this .options .maxBatchSize );
if (batch.length === 0 ) return ;
try {
const results = await this .processBatch (batch.map (b =>audioUrl ));
batch.forEach ((item, index ) => {
item.resolve (results[index]);
});
} catch (error) {
batch.forEach (item =>reject (error));
}
}
private async processBatch (audioUrls : string []): Promise <any []> {
const client = getTwinMindClient ();
const response = await client.post ('/transcribe/batch' , {
audio_urls : audioUrls,
model : 'ear-3' ,
});
return response.data .transcripts ;
}
}
Output
Reliable API calls with automatic retry
Request queue with rate limit awareness
Adaptive throttling based on response patterns
Batch processing for efficiency
Real-time rate limit monitoring
Error Handling Header Description Action X-RateLimit-Limit Max requests per window Monitor total quota X-RateLimit-Remaining Remaining in window Throttle when low X-RateLimit-Reset Unix timestamp of reset Wait until reset Retry-After Seconds to wait Honor this value
Rate Limit Best Practices
Always handle 429 responses - Never let rate limits crash your appUse request queues - Don't burst requestsMonitor remaining quota - Throttle before hitting limitsImplement circuit breakers - Fail fast when API is overloadedCache responses - Avoid redundant requestsBatch when possible - Reduce total request count
Resources
Next Steps For security configuration, see twinmind-security-basics.
Examples Basic usage : Apply twinmind rate limits to a standard project setup with default configuration options.
Advanced scenario : Customize twinmind rate limits for production environments with multiple constraints and team-specific requirements.
