winter-super-cli 2026.5.26 → 2026.5.28

package/resources/local/claude/plugins/marketplaces/anthropic-agent-skills/skills/claude-api/typescript/claude-api/README.md

@@ -1,333 +0,0 @@
-# Claude API — TypeScript
-
-## Installation
-
-```bash
-npm install @anthropic-ai/sdk
-```
-
-## Client Initialization
-
-```typescript
-import Anthropic from "@anthropic-ai/sdk";
-
-// Default (uses ANTHROPIC_API_KEY env var)
-const client = new Anthropic();
-
-// Explicit API key
-const client = new Anthropic({ apiKey: "your-api-key" });
-```
-
----
-
-## Basic Message Request
-
-```typescript
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  messages: [{ role: "user", content: "What is the capital of France?" }],
-});
-// response.content is ContentBlock[] — a discriminated union. Narrow by .type
-// before accessing .text (TypeScript will error on content[0].text without this).
-for (const block of response.content) {
-  if (block.type === "text") {
-    console.log(block.text);
-  }
-}
-```
-
----
-
-## System Prompts
-
-```typescript
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  system:
-    "You are a helpful coding assistant. Always provide examples in Python.",
-  messages: [{ role: "user", content: "How do I read a JSON file?" }],
-});
-```
-
----
-
-## Vision (Images)
-
-### URL
-
-```typescript
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  messages: [
-    {
-      role: "user",
-      content: [
-        {
-          type: "image",
-          source: { type: "url", url: "https://example.com/image.png" },
-        },
-        { type: "text", text: "Describe this image" },
-      ],
-    },
-  ],
-});
-```
-
-### Base64
-
-```typescript
-import fs from "fs";
-
-const imageData = fs.readFileSync("image.png").toString("base64");
-
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  messages: [
-    {
-      role: "user",
-      content: [
-        {
-          type: "image",
-          source: { type: "base64", media_type: "image/png", data: imageData },
-        },
-        { type: "text", text: "What's in this image?" },
-      ],
-    },
-  ],
-});
-```
-
----
-
-## Prompt Caching
-
-**Caching is a prefix match** — any byte change anywhere in the prefix invalidates everything after it. For placement patterns, architectural guidance (frozen system prompt, deterministic tool order, where to put volatile content), and the silent-invalidator audit checklist, read `shared/prompt-caching.md`.
-
-### Automatic Caching (Recommended)
-
-Use top-level `cache_control` to automatically cache the last cacheable block in the request:
-
-```typescript
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  cache_control: { type: "ephemeral" }, // auto-caches the last cacheable block
-  system: "You are an expert on this large document...",
-  messages: [{ role: "user", content: "Summarize the key points" }],
-});
-```
-
-### Manual Cache Control
-
-For fine-grained control, add `cache_control` to specific content blocks:
-
-```typescript
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  system: [
-    {
-      type: "text",
-      text: "You are an expert on this large document...",
-      cache_control: { type: "ephemeral" }, // default TTL is 5 minutes
-    },
-  ],
-  messages: [{ role: "user", content: "Summarize the key points" }],
-});
-
-// With explicit TTL (time-to-live)
-const response2 = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  system: [
-    {
-      type: "text",
-      text: "You are an expert on this large document...",
-      cache_control: { type: "ephemeral", ttl: "1h" }, // 1 hour TTL
-    },
-  ],
-  messages: [{ role: "user", content: "Summarize the key points" }],
-});
-```
-
-### Verifying Cache Hits
-
-```typescript
-console.log(response.usage.cache_creation_input_tokens); // tokens written to cache (~1.25x cost)
-console.log(response.usage.cache_read_input_tokens);     // tokens served from cache (~0.1x cost)
-console.log(response.usage.input_tokens);                // uncached tokens (full cost)
-```
-
-If `cache_read_input_tokens` is zero across repeated identical-prefix requests, a silent invalidator is at work — `Date.now()` or a UUID in the system prompt, non-deterministic key ordering, or a varying tool set. See `shared/prompt-caching.md` for the full audit table.
-
----
-
-## Extended Thinking
-
-> **Opus 4.7, Opus 4.6, and Sonnet 4.6:** Use adaptive thinking. `budget_tokens` is removed on Opus 4.7 (400 if sent); deprecated on Opus 4.6 and Sonnet 4.6.
-> **Older models:** Use `thinking: {type: "enabled", budget_tokens: N}` (must be < `max_tokens`, min 1024).
-
-```typescript
-// Opus 4.7 / 4.6: adaptive thinking (recommended)
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  thinking: { type: "adaptive" },
-  output_config: { effort: "high" }, // low | medium | high | max
-  messages: [
-    { role: "user", content: "Solve this math problem step by step..." },
-  ],
-});
-
-for (const block of response.content) {
-  if (block.type === "thinking") {
-    console.log("Thinking:", block.thinking);
-  } else if (block.type === "text") {
-    console.log("Response:", block.text);
-  }
-}
-```
-
----
-
-## Error Handling
-
-Use the SDK's typed exception classes — never check error messages with string matching:
-
-```typescript
-import Anthropic from "@anthropic-ai/sdk";
-
-try {
-  const response = await client.messages.create({...});
-} catch (error) {
-  if (error instanceof Anthropic.BadRequestError) {
-    console.error("Bad request:", error.message);
-  } else if (error instanceof Anthropic.AuthenticationError) {
-    console.error("Invalid API key");
-  } else if (error instanceof Anthropic.RateLimitError) {
-    console.error("Rate limited - retry later");
-  } else if (error instanceof Anthropic.APIError) {
-    console.error(`API error ${error.status}:`, error.message);
-  }
-}
-```
-
-All classes extend `Anthropic.APIError` with a typed `status` field. Check from most specific to least specific. See [shared/error-codes.md](../../shared/error-codes.md) for the full error code reference.
-
----
-
-## Multi-Turn Conversations
-
-The API is stateless — send the full conversation history each time. Use `Anthropic.MessageParam[]` to type the messages array:
-
-```typescript
-const messages: Anthropic.MessageParam[] = [
-  { role: "user", content: "My name is Alice." },
-  { role: "assistant", content: "Hello Alice! Nice to meet you." },
-  { role: "user", content: "What's my name?" },
-];
-
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  messages: messages,
-});
-```
-
-**Rules:**
-
-- Consecutive same-role messages are allowed — the API combines them into a single turn
-- First message must be `user`
-- Use SDK types (`Anthropic.MessageParam`, `Anthropic.Message`, `Anthropic.Tool`, etc.) for all API data structures — don't redefine equivalent interfaces
-
----
-
-### Compaction (long conversations)
-
-> **Beta, Opus 4.7, Opus 4.6, and Sonnet 4.6.** When conversations approach the 200K context window, compaction automatically summarizes earlier context server-side. The API returns a `compaction` block; you must pass it back on subsequent requests — append `response.content`, not just the text.
-
-```typescript
-import Anthropic from "@anthropic-ai/sdk";
-
-const client = new Anthropic();
-const messages: Anthropic.Beta.BetaMessageParam[] = [];
-
-async function chat(userMessage: string): Promise<string> {
-  messages.push({ role: "user", content: userMessage });
-
-  const response = await client.beta.messages.create({
-    betas: ["compact-2026-01-12"],
-    model: "claude-opus-4-7",
-    max_tokens: 16000,
-    messages,
-    context_management: {
-      edits: [{ type: "compact_20260112" }],
-    },
-  });
-
-  // Append full content — compaction blocks must be preserved
-  messages.push({ role: "assistant", content: response.content });
-
-  const textBlock = response.content.find(
-    (b): b is Anthropic.Beta.BetaTextBlock => b.type === "text",
-  );
-  return textBlock?.text ?? "";
-}
-
-// Compaction triggers automatically when context grows large
-console.log(await chat("Help me build a Python web scraper"));
-console.log(await chat("Add support for JavaScript-rendered pages"));
-console.log(await chat("Now add rate limiting and error handling"));
-```
-
----
-
-## Stop Reasons
-
-The `stop_reason` field in the response indicates why the model stopped generating:
-
-| Value           | Meaning                                                         |
-| --------------- | --------------------------------------------------------------- |
-| `end_turn`      | Claude finished its response naturally                          |
-| `max_tokens`    | Hit the `max_tokens` limit — increase it or use streaming       |
-| `stop_sequence` | Hit a custom stop sequence                                      |
-| `tool_use`      | Claude wants to call a tool — execute it and continue           |
-| `pause_turn`    | Model paused and can be resumed (agentic flows)                 |
-| `refusal`       | Claude refused for safety reasons — output may not match schema |
-
----
-
-## Cost Optimization Strategies
-
-### 1. Use Prompt Caching for Repeated Context
-
-```typescript
-// Automatic caching (simplest — caches the last cacheable block)
-const response = await client.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  cache_control: { type: "ephemeral" },
-  system: largeDocumentText, // e.g., 50KB of context
-  messages: [{ role: "user", content: "Summarize the key points" }],
-});
-
-// First request: full cost
-// Subsequent requests: ~90% cheaper for cached portion
-```
-
-### 2. Use Token Counting Before Requests
-
-```typescript
-const countResponse = await client.messages.countTokens({
-  model: "claude-opus-4-7",
-  messages: messages,
-  system: system,
-});
-
-const estimatedInputCost = countResponse.input_tokens * 0.000005; // $5/1M tokens
-console.log(`Estimated input cost: $${estimatedInputCost.toFixed(4)}`);
-```

package/resources/local/claude/plugins/marketplaces/anthropic-agent-skills/skills/claude-api/typescript/claude-api/batches.md

@@ -1,106 +0,0 @@
-# Message Batches API — TypeScript
-
-The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.
-
-## Key Facts
-
-- Up to 100,000 requests or 256 MB per batch
-- Most batches complete within 1 hour; maximum 24 hours
-- Results available for 29 days after creation
-- 50% cost reduction on all token usage
-- All Messages API features supported (vision, tools, caching, etc.)
-
----
-
-## Create a Batch
-
-```typescript
-import Anthropic from "@anthropic-ai/sdk";
-
-const client = new Anthropic();
-
-const messageBatch = await client.messages.batches.create({
-  requests: [
-    {
-      custom_id: "request-1",
-      params: {
-        model: "claude-opus-4-7",
-        max_tokens: 16000,
-        messages: [
-          { role: "user", content: "Summarize climate change impacts" },
-        ],
-      },
-    },
-    {
-      custom_id: "request-2",
-      params: {
-        model: "claude-opus-4-7",
-        max_tokens: 16000,
-        messages: [
-          { role: "user", content: "Explain quantum computing basics" },
-        ],
-      },
-    },
-  ],
-});
-
-console.log(`Batch ID: ${messageBatch.id}`);
-console.log(`Status: ${messageBatch.processing_status}`);
-```
-
----
-
-## Poll for Completion
-
-```typescript
-let batch;
-while (true) {
-  batch = await client.messages.batches.retrieve(messageBatch.id);
-  if (batch.processing_status === "ended") break;
-  console.log(
-    `Status: ${batch.processing_status}, processing: ${batch.request_counts.processing}`,
-  );
-  await new Promise((resolve) => setTimeout(resolve, 60_000));
-}
-
-console.log("Batch complete!");
-console.log(`Succeeded: ${batch.request_counts.succeeded}`);
-console.log(`Errored: ${batch.request_counts.errored}`);
-```
-
----
-
-## Retrieve Results
-
-```typescript
-for await (const result of await client.messages.batches.results(
-  messageBatch.id,
-)) {
-  switch (result.result.type) {
-    case "succeeded":
-      console.log(
-        `[${result.custom_id}] ${result.result.message.content[0].text.slice(0, 100)}`,
-      );
-      break;
-    case "errored":
-      if (result.result.error.type === "invalid_request") {
-        console.log(`[${result.custom_id}] Validation error - fix and retry`);
-      } else {
-        console.log(`[${result.custom_id}] Server error - safe to retry`);
-      }
-      break;
-    case "expired":
-      console.log(`[${result.custom_id}] Expired - resubmit`);
-      break;
-  }
-}
-```
-
----
-
-## Cancel a Batch
-
-```typescript
-const cancelled = await client.messages.batches.cancel(messageBatch.id);
-console.log(`Status: ${cancelled.processing_status}`); // "canceling"
-```

package/resources/local/claude/plugins/marketplaces/anthropic-agent-skills/skills/claude-api/typescript/claude-api/files-api.md

@@ -1,98 +0,0 @@
-# Files API — TypeScript
-
-The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.
-
-**Beta:** Pass `betas: ["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).
-
-## Key Facts
-
-- Maximum file size: 500 MB
-- Total storage: 100 GB per organization
-- Files persist until deleted
-- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
-- Not available on Amazon Bedrock or Google Vertex AI
-
----
-
-## Upload a File
-
-```typescript
-import Anthropic, { toFile } from "@anthropic-ai/sdk";
-import fs from "fs";
-
-const client = new Anthropic();
-
-const uploaded = await client.beta.files.upload({
-  file: await toFile(fs.createReadStream("report.pdf"), undefined, {
-    type: "application/pdf",
-  }),
-  betas: ["files-api-2025-04-14"],
-});
-
-console.log(`File ID: ${uploaded.id}`);
-console.log(`Size: ${uploaded.size_bytes} bytes`);
-```
-
----
-
-## Use a File in Messages
-
-### PDF / Text Document
-
-```typescript
-const response = await client.beta.messages.create({
-  model: "claude-opus-4-7",
-  max_tokens: 16000,
-  messages: [
-    {
-      role: "user",
-      content: [
-        { type: "text", text: "Summarize the key findings in this report." },
-        {
-          type: "document",
-          source: { type: "file", file_id: uploaded.id },
-          title: "Q4 Report",
-          citations: { enabled: true },
-        },
-      ],
-    },
-  ],
-  betas: ["files-api-2025-04-14"],
-});
-
-console.log(response.content[0].text);
-```
-
----
-
-## Manage Files
-
-### List Files
-
-```typescript
-const files = await client.beta.files.list({
-  betas: ["files-api-2025-04-14"],
-});
-for (const f of files.data) {
-  console.log(`${f.id}: ${f.filename} (${f.size_bytes} bytes)`);
-}
-```
-
-### Delete a File
-
-```typescript
-await client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w", {
-  betas: ["files-api-2025-04-14"],
-});
-```
-
-### Download a File
-
-```typescript
-const response = await client.beta.files.download(
-  "file_011CNha8iCJcU1wXNR6q4V8w",
-  { betas: ["files-api-2025-04-14"] },
-);
-const content = Buffer.from(await response.arrayBuffer());
-await fs.promises.writeFile("output.txt", content);
-```

package/resources/local/claude/plugins/marketplaces/anthropic-agent-skills/skills/claude-api/typescript/claude-api/streaming.md

@@ -1,178 +0,0 @@
-# Streaming — TypeScript
-
-## Quick Start
-
-```typescript
-const stream = client.messages.stream({
-  model: "claude-opus-4-7",
-  max_tokens: 64000,
-  messages: [{ role: "user", content: "Write a story" }],
-});
-
-for await (const event of stream) {
-  if (
-    event.type === "content_block_delta" &&
-    event.delta.type === "text_delta"
-  ) {
-    process.stdout.write(event.delta.text);
-  }
-}
-```
-
----
-
-## Handling Different Content Types
-
-> **Opus 4.7 / Opus 4.6:** Use `thinking: {type: "adaptive"}`. On older models, use `thinking: {type: "enabled", budget_tokens: N}` instead.
-
-```typescript
-const stream = client.messages.stream({
-  model: "claude-opus-4-7",
-  max_tokens: 64000,
-  thinking: { type: "adaptive" },
-  messages: [{ role: "user", content: "Analyze this problem" }],
-});
-
-for await (const event of stream) {
-  switch (event.type) {
-    case "content_block_start":
-      switch (event.content_block.type) {
-        case "thinking":
-          console.log("\n[Thinking...]");
-          break;
-        case "text":
-          console.log("\n[Response:]");
-          break;
-      }
-      break;
-    case "content_block_delta":
-      switch (event.delta.type) {
-        case "thinking_delta":
-          process.stdout.write(event.delta.thinking);
-          break;
-        case "text_delta":
-          process.stdout.write(event.delta.text);
-          break;
-      }
-      break;
-  }
-}
-```
-
----
-
-## Streaming with Tool Use (Tool Runner)
-
-Use the tool runner with `stream: true`. The outer loop iterates over tool runner iterations (messages), the inner loop processes stream events:
-
-```typescript
-import Anthropic from "@anthropic-ai/sdk";
-import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
-import { z } from "zod";
-
-const client = new Anthropic();
-
-const getWeather = betaZodTool({
-  name: "get_weather",
-  description: "Get current weather for a location",
-  inputSchema: z.object({
-    location: z.string().describe("City and state, e.g., San Francisco, CA"),
-  }),
-  run: async ({ location }) => `72°F and sunny in ${location}`,
-});
-
-const runner = client.beta.messages.toolRunner({
-  model: "claude-opus-4-7",
-  max_tokens: 64000,
-  tools: [getWeather],
-  messages: [
-    { role: "user", content: "What's the weather in Paris and London?" },
-  ],
-  stream: true,
-});
-
-// Outer loop: each tool runner iteration
-for await (const messageStream of runner) {
-  // Inner loop: stream events for this iteration
-  for await (const event of messageStream) {
-    switch (event.type) {
-      case "content_block_delta":
-        switch (event.delta.type) {
-          case "text_delta":
-            process.stdout.write(event.delta.text);
-            break;
-          case "input_json_delta":
-            // Tool input being streamed
-            break;
-        }
-        break;
-    }
-  }
-}
-```
-
----
-
-## Getting the Final Message
-
-```typescript
-const stream = client.messages.stream({
-  model: "claude-opus-4-7",
-  max_tokens: 64000,
-  messages: [{ role: "user", content: "Hello" }],
-});
-
-for await (const event of stream) {
-  // Process events...
-}
-
-const finalMessage = await stream.finalMessage();
-console.log(`Tokens used: ${finalMessage.usage.output_tokens}`);
-```
-
----
-
-## Stream Event Types
-
-| Event Type            | Description                 | When it fires                     |
-| --------------------- | --------------------------- | --------------------------------- |
-| `message_start`       | Contains message metadata   | Once at the beginning             |
-| `content_block_start` | New content block beginning | When a text/tool_use block starts |
-| `content_block_delta` | Incremental content update  | For each token/chunk              |
-| `content_block_stop`  | Content block complete      | When a block finishes             |
-| `message_delta`       | Message-level updates       | Contains `stop_reason`, usage     |
-| `message_stop`        | Message complete            | Once at the end                   |
-
-## Best Practices
-
-1. **Always flush output** — Use `process.stdout.write()` for immediate display
-2. **Handle partial responses** — If the stream is interrupted, you may have incomplete content
-3. **Track token usage** — The `message_delta` event contains usage information
-4. **Use `finalMessage()`** — Get the complete `Anthropic.Message` object even when streaming. Don't wrap `.on()` events in `new Promise()` — `finalMessage()` handles all completion/error/abort states internally
-5. **Buffer for web UIs** — Consider buffering a few tokens before rendering to avoid excessive DOM updates
-6. **Use `stream.on("text", ...)` for deltas** — The `text` event provides just the delta string, simpler than manually filtering `content_block_delta` events
-7. **For agentic loops with streaming** — See the [Streaming Manual Loop](./tool-use.md#streaming-manual-loop) section in tool-use.md for combining `stream()` + `finalMessage()` with a tool-use loop
-
-## Raw SSE Format
-
-If using raw HTTP (not SDKs), the stream returns Server-Sent Events:
-
-```
-event: message_start
-data: {"type":"message_start","message":{"id":"msg_...","type":"message",...}}
-
-event: content_block_start
-data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
-
-event: content_block_delta
-data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}
-
-event: content_block_stop
-data: {"type":"content_block_stop","index":0}
-
-event: message_delta
-data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":12}}
-
-event: message_stop
-data: {"type":"message_stop"}
-```