@clickzetta/cz-cli-darwin-arm64 0.5.16 → 0.5.17

package/bin/skills/lakehouse-doc-en/references/pipe-syntax.md

@@ -1,183 +1,90 @@
-# Pipe Syntax
+# Pipe
 
-Pipe is a continuous data ingestion object that automates importing data from object storage or Kafka into the Lakehouse. This document provides a complete reference for Pipe-related SQL syntax.
+Pipe is the continuous data ingestion object in the Lakehouse. Once created via SQL DDL, it runs automatically, continuously reading data from object storage (OSS/COS/S3) or Kafka and writing it to a target table.
 
-## Create Pipe
+For a detailed introduction, see [Pipe Object Model](om-pipe.md).
 
-### Import Data from Object Storage
+---
 
-```SQL
-CREATE PIPE [IF NOT EXISTS] <pipe_name>
-    VIRTUAL_CLUSTER = 'virtual_cluster_name'
-    INGEST_MODE = 'LIST_PURGE' | 'EVENT_NOTIFICATION'
-    [COPY_JOB_HINT = '']
-AS <copy_statement>;
-```
-
-**Parameter Description:**
+## Chapter Contents
 
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `pipe_name` | Yes | Name of the Pipe object |
-| `VIRTUAL_CLUSTER` | Yes | Name of the compute cluster used to execute COPY jobs |
-| `INGEST_MODE` | Yes | Data ingestion mode: `LIST_PURGE` (polling scan) or `EVENT_NOTIFICATION` (event notification trigger) |
-| `COPY_JOB_HINT` | No | Lakehouse reserved parameter. Supports `IGNORE_TMP_FILE` (value `true`\|`false`, default `true`), which filters files or directories starting with `.` or `_temporary` |
-| `copy_statement` | Yes | A standard `COPY INTO` statement. Supports the `ON_ERROR=CONTINUE\|ABORT` parameter for error handling strategy |
+| Page | Description |
+|------|-------------|
+| [CREATE PIPE](create-pipe.md) | Create an object storage Pipe or Kafka Pipe |
+| [ALTER PIPE](alter-pipe.md) | Pause, resume, or modify batch interval and other properties |
+| [DROP PIPE](drop-pipe.md) | Drop a Pipe (does not affect target table data) |
+| [SHOW PIPES](show-pipes.md) | List all Pipes in the current Schema |
+| [SHOW CREATE PIPE](show-create-pipe.md) | View the creation statement of a Pipe |
+| [DESC PIPE](desc-pipe.md) | View Pipe details including status, source, target, and latency |
 
-**Usage Restrictions:**
+---
 
-- COPY statements in a Pipe do not support the `FILES`, `REGEXP`, or `SUBDIRECTORY` parameters.
-- Each Pipe must correspond to an independent Volume; Volumes cannot be reused.
+## Common Operations
 
-**Reference:** [Import Data Continuously from Object Storage Using Pipe](pipe-storage-object.md)
-
-### Import Data from Kafka
+### Create an Object Storage Pipe
 
 ```SQL
-CREATE PIPE [IF NOT EXISTS] <pipe_name>
-    VIRTUAL_CLUSTER = 'virtual_cluster_name'
-    [INITIAL_DELAY_IN_SECONDS = '']
-    [BATCH_INTERVAL_IN_SECONDS = '']
-    [BATCH_SIZE_PER_KAFKA_PARTITION = '']
-    [MAX_SKIP_BATCH_COUNT_ON_ERROR = '']
-    [RESET_KAFKA_GROUP_OFFSETS = '']
-    [COPY_JOB_HINT = '']
-AS <copy_statement>;
+-- LIST_PURGE mode: periodic polling, deletes source files after import
+CREATE PIPE orders_pipe
+    VIRTUAL_CLUSTER = 'DEFAULT'
+    INGEST_MODE = 'LIST_PURGE'
+AS
+COPY INTO orders FROM VOLUME orders_vol USING CSV OPTIONS('header' = 'true');
 ```
 
-**Parameter Description:**
-
-| Parameter | Required | Default | Description |
-|-----------|----------|---------|-------------|
-| `VIRTUAL_CLUSTER` | Yes | -- | Name of the compute cluster used to execute COPY jobs |
-| `INITIAL_DELAY_IN_SECONDS` | No | 0 | Initial delay in seconds before the first job is scheduled |
-| `BATCH_INTERVAL_IN_SECONDS` | No | 60 | Batch interval in seconds |
-| `BATCH_SIZE_PER_KAFKA_PARTITION` | No | 500000 | Maximum number of messages per batch for each Kafka partition |
-| `MAX_SKIP_BATCH_COUNT_ON_ERROR` | No | 30 | Maximum number of retries when skipping batches on error |
-| `RESET_KAFKA_GROUP_OFFSETS` | No | none | Initial Kafka offset when starting the Pipe. Possible values: `none` (no action), `valid` (reset expired offsets), `earliest`, `latest`, `${TIMESTAMP_MILLISECONDS}` |
+> ⚠️ `LIST_PURGE` mode **permanently deletes** source files from OSS after a successful import. This is irreversible. Use `EVENT_NOTIFICATION` mode if you need to retain the files.
 
-**Reference:**
-
-- [Import Kafka Data Continuously Using read_kafka](pipe-kafka.md)
-- [Import Kafka Data Continuously Using Kafka Table Stream](pipe-kafka-table-stream.md)
-
-## Pause and Resume Pipe
-
-Control the execution state of a Pipe:
+### Create a Kafka Pipe
 
 ```SQL
--- Pause Pipe
-ALTER PIPE pipe_name SET PIPE_EXECUTION_PAUSED = true;
-
--- Resume Pipe
-ALTER PIPE pipe_name SET PIPE_EXECUTION_PAUSED = false;
+CREATE PIPE kafka_orders_pipe
+    VIRTUAL_CLUSTER = 'DEFAULT'
+    BATCH_INTERVAL_IN_SECONDS = '60'
+AS
+COPY INTO orders_raw
+FROM (
+    SELECT CAST(value AS STRING) AS raw_msg
+    FROM TABLE(READ_KAFKA(
+        'kafka-host:9092', 'orders_topic', '',
+        'pipe_orders_group', '', '', '', '',
+        'raw', 'raw', 0, map()
+    ))
+);
 ```
 
-## Modify Pipe Properties
-
-Modify the configuration properties of a Pipe. Only one property can be modified at a time; to modify multiple properties, execute multiple `ALTER` commands.
+### Pause and Resume
 
 ```SQL
-ALTER PIPE pipe_name SET
-    [VIRTUAL_CLUSTER = 'virtual_cluster_name']
-    | [BATCH_INTERVAL_IN_SECONDS = '']
-    | [BATCH_SIZE_PER_KAFKA_PARTITION = '']
-    | [MAX_SKIP_BATCH_COUNT_ON_ERROR = '']
-    | [COPY_JOB_HINT = ''];
-```
+-- Pause
+ALTER PIPE orders_pipe SET PIPE_EXECUTION_PAUSED = TRUE;
 
-**Examples:**
+-- Resume
+ALTER PIPE orders_pipe SET PIPE_EXECUTION_PAUSED = FALSE;
 
-```SQL
--- Modify the compute cluster
-ALTER PIPE pipe_name SET VIRTUAL_CLUSTER = 'default';
--- Set COPY_JOB_HINT
-ALTER PIPE pipe_name SET COPY_JOB_HINT = '{"cz.mapper.kafka.message.size": "2000000"}';
+-- Trigger an immediate scan
+ALTER PIPE orders_pipe REFRESH;
 ```
 
-## View Pipe List
-
-List all Pipe objects within the specified scope:
+### View and Drop
 
 ```SQL
--- List all Pipes in the current schema
+-- View all Pipes
 SHOW PIPES;
--- List all Pipes in a specified schema
-SHOW PIPES IN SCHEMA schema_name;
--- List all Pipes in a specified workspace
-SHOW PIPES IN WORKSPACE workspace_name;
-```
-
-**Return Columns:**
-
-| Column Name | Description |
-|-------------|-------------|
-| `pipe_name` | Pipe name |
-| `pipe_kind` | Pipe type (object storage or Kafka) |
-| `status` | Current status, e.g., `RUNNING`, `PAUSED`, `INVALID` |
-| `copy_statement` | The COPY INTO statement associated with the Pipe |
-
-## View Pipe Details
-
-View detailed information about a specific Pipe object:
-
-```SQL
-DESC PIPE [EXTENDED] <name>;
-```
-
-**Sample Output:**
-
-```
-DESC PIPE EXTENDED kafka_pipe_stream;
-+--------------------+-----------------------------------------------------+
-|     info_name      |                     info_value                      |
-+--------------------+-----------------------------------------------------+
-| name               | kafka_pipe_stream                                   |
-| creator            | UAT_TEST                                            |
-| created_time       | 2025-03-05 10:40:55.405                             |
-| last_modified_time | 2025-03-05 10:40:55.405                             |
-| comment            |                                                     |
-| properties         | ((virtual_cluster,test_alter))                      |
-| copy_statement     | COPY INTO TABLE example.pipe_schema.sink_table ...  |
-| pipe_status        | RUNNING                                             |
-| output_name        | workspace.pipe_schema.sink_table                    |
-| input_name         | kafka_table_stream:workspace.pipe_schema.stream1    |
-| invalid_reason     |                                                     |
-| pipe_latency       | {"kafka":{"lags":{"0":0},"offsetLag":0}}            |
-+--------------------+-----------------------------------------------------+
-```
-
-## View Pipe Creation Statement
-
-```SQL
-SHOW CREATE PIPE <name>;
-```
-
-## Drop Pipe
 
-When a Pipe object is no longer needed, use the following command to delete it:
+-- View Pipe details
+DESC PIPE orders_pipe;
 
-```SQL
-DROP PIPE <name>;
-```
-
-## load_history Function
-
-**Description**: View the COPY job import file history of a table, with a retention period of 7 days. When a Pipe runs, it uses `load_history` to avoid re-importing existing files, ensuring data uniqueness.
-
-**Syntax:**
-
-```SQL
-load_history('schema_name.table_name')
+-- Drop a Pipe
+DROP PIPE orders_pipe;
 ```
 
-**Example:**
-
-```SQL
-SELECT * FROM load_history('myschema.mytable');
-```
+---
 
-## Constraints and Limitations
+## Related Documentation
 
-- When the data source is Kafka: Only one `read_kafka` function is allowed in a Pipe.
-- When the data source is object storage: Only one Volume object is allowed in a Pipe.
+| Document | Description |
+|----------|-------------|
+| [Pipe Object Model](om-pipe.md) | Core concepts, comparison of two modes, deduplication mechanism, complete parameter reference |
+| [Object Storage Pipe Detailed Configuration](pipe-storage-object.md) | Complete configuration for EVENT_NOTIFICATION mode |
+| [Kafka Pipe Detailed Configuration](pipe-kafka.md) | READ_KAFKA parameter reference, consumer offset management |
+| [Real-time Pipeline Selection Guide](realtime-pipeline-selection-guide.md) | Comparison and selection guide for Pipe / Stream / Dynamic Table |

package/bin/skills/lakehouse-doc-en/references/practice_python_task.md

@@ -6,7 +6,7 @@ In the task development module, the Python task provided is a specific task type
 
 ### Runtime Environment and Customization
 
-Python tasks are executed in a system preset Pod environment, with the pre-installed Python version being Python 3 (current version is 3.9.2, which may be updated in the future).
+Python tasks are executed in a system preset Pod environment, with the pre-installed Python version being Python 3 (current version is 3.10, which may be updated in the future).
 
 The default system image includes some commonly used dependency packages to support connection and data access with Singdata Lakehouse, as well as operations on object storage services such as Alibaba Cloud OSS and Tencent Cloud COS. These dependencies include but are not limited to:
 
@@ -111,7 +111,7 @@ conn = connect(
     instance='your_instance',
     workspace='your_workspace',
     schema='public',
-    vcluster='default'
+    vcluster='DEFAULT'
 )
 
 ```
@@ -148,7 +148,7 @@ from sqlalchemy import text
 
 ```
 
-Create an instance of the SQLAlchemy engine for ClickZetta Lakehouse:
+Create an instance of the SQLAlchemy engine for Singdata Lakehouse:
 
 ```py
 engine = create_engine(
@@ -185,7 +185,7 @@ conn = connect(
     instance='your_instance',
     workspace='your_workspace',
     schema='public',
-    vcluster='default'
+    vcluster='DEFAULT'
 )
 
 bulkload_stream = conn.create_bulkload_stream(schema='public', table='bulkload_test')

package/bin/skills/lakehouse-doc-en/references/pricing-ai-gateway.md

@@ -0,0 +1,181 @@
+# AI Gateway Pricing
+
+This page describes the pricing model and list prices of Singdata AI Gateway in overseas regions (USD). For Lakehouse compute, storage, and network resources, see [Lakehouse Pricing](pricing-lakehouse.md). The pricing entry point is [Pricing and Billing](pricing.md).
+
+## Overview
+
+Singdata AI Gateway is a one-stop platform that aggregates and manages mainstream LLMs (Anthropic Claude, OpenAI GPT, Qwen, DeepSeek, GLM, Kimi, MiniMax, and more) behind a unified API, so you do not have to register, integrate, and fund a separate account on each vendor's platform.
+
+> 💡 **Tip**: When Analytics Agent calls an LLM, the resulting token consumption is billed at the per-model unit prices listed in this document.
+
+## Billing Modes
+
+### Pay-as-you-go
+
+Each API call is billed by the number of tokens it actually consumes, with no minimum spend. Metering is captured at the individual call level and can be aggregated by API key, application, or tenant. Bills are issued monthly, and itemized usage is available in the Billing Center of the console.
+
+## Billing Dimensions
+
+Different model types are billed along different dimensions. The fields used in the price tables below have the following meanings.
+
+### Chat Models Billed by Token
+
+Input and output are priced separately. One token is roughly 0.5 Chinese characters or 0.75 English words.
+
+| Field | Meaning |
+| --- | --- |
+| Input | Unit price for tokens in the prompt portion of the request |
+| Output | Unit price for tokens generated by the model |
+| Context Window | Tiered pricing across context-window ranges; tokens are billed at the unit price of the tier their request falls into |
+
+> 💡 **Tip**: For example, a Q&A with 1,000 characters of input and 2,000 characters of output is roughly 1,000 input tokens and 2,000 output tokens. With an input price of $2 per million tokens and an output price of $8 per million tokens, the call costs about `1000÷1,000,000×2 + 2000÷1,000,000×8 = $0.018`.
+
+### Caching and Cost Savings
+
+If you repeatedly send the same leading content (a long system prompt, a fixed knowledge base document, and so on), the model can keep that content available for reuse on subsequent calls instead of recomputing it from scratch. That is what caching does. Tokens that hit the cache are priced well below the standard input price, which can substantially reduce cost for long prompts and multi-turn conversations.
+
+There are two types of caching, mapped to different columns in the price tables.
+
+| Type | How It Works | Corresponding Columns in Price Table |
+| --- | --- | --- |
+| Explicit Cache | You explicitly tell the model to store a segment. A one-time write fee applies on creation (slightly higher than the input price), and a much lower hit fee applies on each subsequent reuse | Explicit·Write, Explicit·Write·5min, Explicit·Write·1h, Explicit·Hit |
+| Implicit Cache | The system automatically detects repeated prefixes and caches them, with no manual action required. There is no write fee; only the lower hit price applies on hits | Implicit·Hit |
+
+How each column is billed:
+
+- **Explicit·Write**: Charged when a prompt segment is first written to the cache, calculated as the number of tokens written multiplied by this unit price
+- **Explicit·Write·5min / Explicit·Write·1h**: Anthropic Claude's explicit cache offers two retention tiers. The 5-minute tier has a lower unit price; the 1-hour tier has a higher unit price but suits cases where the same content is reused repeatedly within an hour
+- **Explicit·Hit**: Charged when a subsequent request hits the cache, calculated as the number of hit tokens multiplied by this unit price, which is significantly lower than the input price
+- **Implicit·Hit**: When the system detects a repeated prefix in a request, the hit portion is billed at this unit price. Because the system writes to the cache automatically, no separate write fee applies
+
+Vendors differ in which cache types they support. The matrix below summarizes current support:
+
+| Vendor | Explicit Cache | Implicit Cache |
+| --- | --- | --- |
+| Anthropic Claude | Supported (5-minute and 1-hour write tiers) | Not supported |
+| OpenAI GPT | Not supported | Supported |
+| Qwen | Supported | Partially supported (3.5 series supported; 3.6 / 3.7 series not yet available) |
+| DeepSeek | Partially supported (v3.2 supported) | Supported |
+| GLM | Partially supported (5.1 supported) | Supported |
+| Kimi | Supported | Supported |
+| MiniMax | Not supported | Supported |
+
+### How Multimodal Embeddings Are Billed
+
+Embedding models are priced separately by input data type. Text input uses a single input price, while image and video inputs are billed by the number of multimodal tokens at a unit price higher than text input.
+
+## Overseas Model List Prices
+
+> ⚠️ **Note**: The prices below are public list prices, in USD per million tokens (USD / M tokens). **Model market prices fluctuate, and list prices may change as the market changes. Actual settled prices follow the bill.** Overseas list prices exclude tax. VAT will be charged separately according to local tax requirements (for example, in Singapore an additional 9% GST applies per local regulations).
+
+### Anthropic Claude Series
+
+| Model | Input | Output | Explicit·Write·5min | Explicit·Write·1h | Explicit·Hit |
+| --- | --- | --- | --- | --- | --- |
+| claude-opus-4-7 | 5 | 25 | 6.25 | 10 | 0.5 |
+| claude-opus-4-6 | 5 | 25 | 6.25 | 10 | 0.5 |
+| claude-opus-4-5 | 5 | 25 | 6.25 | 10 | 0.5 |
+| claude-sonnet-4-6 | 3 | 15 | 3.75 | 6 | 0.3 |
+| claude-sonnet-4-5 | 3 | 15 | 3.75 | 6 | 0.3 |
+| claude-haiku-4-5 | 1 | 5 | 1.25 | 2 | 0.1 |
+
+### OpenAI GPT Series
+
+| Model | Context Window | Input | Output | Implicit·Hit |
+| --- | --- | --- | --- | --- |
+| gpt-5.4-pro | ≤272K | 30 | 180 | — |
+| gpt-5.4-pro | >272K | 60 | 270 | — |
+| gpt-5.4 | ≤272K | 2.5 | 15 | 0.25 |
+| gpt-5.4 | >272K | 5 | 22.5 | 0.5 |
+| gpt-5.4-mini | — | 0.75 | 4.5 | 0.075 |
+| gpt-5.5 | ≤272K | 5 | 30 | 0.5 |
+| gpt-5.5 | >272K | 10 | 45 | 1 |
+| gpt-5.2-pro | — | 21 | 168 | — |
+| gpt-5.2-2025-12-11 | 1M tokens | 1.75 | 14 | 0.175 |
+| gpt-5-2025-08-07 | 1M tokens | 1.25 | 10 | 0.125 |
+| gpt-5-mini-2025-08-07 | 1M tokens | 0.25 | 2 | 0.025 |
+| gpt-5-nano-2025-08-07 | 1M tokens | 0.05 | 0.4 | 0.005 |
+| gpt-4.1-2025-04-14 | 1M tokens | 2 | 8 | 0.5 |
+| gpt-4.1-mini-2025-04-14 | 1M tokens | 0.4 | 1.6 | 0.1 |
+| gpt-4o-2024-08-06 | 128K tokens | 2.5 | 10 | 1.25 |
+| o4-mini | — | 1.1 | 4.4 | 0.275 |
+| o3 | — | 2 | 8 | 0.5 |
+
+### Qwen Series
+
+| Sub-series | Model | Context Window | Input | Output | Explicit·Write | Explicit·Hit | Implicit·Hit |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Qwen Max | qwen3.7-max | 0–1M | 2.5 | 7.5 | 3.125 | 0.25 | 0.5 |
+| Qwen Max | qwen3.6-max-preview | 0–128K | 1.3 | 7.8 | 1.625 | 0.13 | — |
+| Qwen Max | qwen3.6-max-preview | 128K–256K | 2 | 12 | 2.5 | 0.2 | — |
+| Qwen Max | qwen3-max | 0–32K | 1.2 | 6 | 1.5 | 0.12 | 0.24 |
+| Qwen Max | qwen3-max | 32K–128K | 2.4 | 12 | 3 | 0.24 | 0.48 |
+| Qwen Max | qwen3-max | 128K–256K | 3 | 15 | 3.75 | 0.3 | 0.6 |
+| Qwen Max | qwen3-max-preview | 0–32K | 1.2 | 6 | 1.5 | 0.12 | 0.24 |
+| Qwen Max | qwen3-max-preview | 32K–128K | 2.4 | 12 | 3 | 0.24 | 0.48 |
+| Qwen Max | qwen3-max-preview | 128K–256K | 3 | 15 | 3.75 | 0.3 | 0.6 |
+| Qwen Plus | qwen3.6-plus | 0–256K | 0.5 | 3 | 0.625 | 0.05 | — |
+| Qwen Plus | qwen3.6-plus | 256K–1M | 2 | 6 | 2.5 | 0.2 | — |
+| Qwen Plus | qwen3.5-plus | 0–256K | 0.4 | 2.4 | 0.5 | 0.04 | 0.08 |
+| Qwen Plus | qwen3.5-plus | 256K–1M | 0.5 | 3 | 0.625 | 0.05 | 0.1 |
+| Qwen Flash | qwen3.6-flash | 0–256K | 0.25 | 1.5 | 0.3125 | 0.025 | — |
+| Qwen Flash | qwen3.6-flash | 256K–1M | 1 | 4 | 1.25 | 0.1 | — |
+| Qwen Flash | qwen3.5-flash | 0–1M | 0.1 | 0.4 | 0.125 | 0.01 | — |
+| Qwen Embedding | qwen3-vl-embedding (text input) | — | 0.1 | — | — | — | — |
+| Qwen Embedding | qwen3-vl-embedding (image / video input) | — | 0.258 | — | — | — | — |
+
+### DeepSeek Series
+
+| Model | Input | Output | Explicit·Write | Explicit·Hit | Implicit·Hit |
+| --- | --- | --- | --- | --- | --- |
+| deepseek-v3.2 | 0.57 | 1.71 | 0.7125 | 0.057 | 0.114 |
+| deepseek-v4-flash | 0.2 | 0.4 | — | — | — |
+| deepseek-v4-pro | 2.4 | 4.8 | — | — | — |
+
+### GLM Series
+
+| Model | Context Window | Input | Output | Explicit·Write | Explicit·Hit | Implicit·Hit |
+| --- | --- | --- | --- | --- | --- | --- |
+| glm-4.7 | 0–32K | 0.431 | 2.007 | — | — | 0.0862 |
+| glm-4.7 | 32K–166K | 0.574 | 2.294 | — | — | 0.1148 |
+| glm-5 | 0–32K | 0.573 | 2.58 | — | — | 0.1146 |
+| glm-5 | 32K–166K | 0.86 | 3.154 | — | — | 0.172 |
+| glm-5.1 | 0–32K | 0.825 | 3.301 | 1.03125 | 0.0825 | 0.165 |
+| glm-5.1 | 32K–200K | 1.1 | 3.851 | 1.375 | 0.11 | 0.22 |
+
+### Kimi Series
+
+| Model | Input | Output | Explicit·Write | Explicit·Hit | Implicit·Hit |
+| --- | --- | --- | --- | --- | --- |
+| kimi-k2.5 | 0.574 | 3.011 | 0.7175 | 0.0574 | 0.1148 |
+| kimi-k2.6 | 0.8939 | 3.7131 | 1.117375 | 0.08939 | 0.17878 |
+
+### MiniMax Series
+
+| Model | Input | Output | Implicit·Hit |
+| --- | --- | --- | --- |
+| MiniMax-M2.5 | 0.304 | 1.213 | 0.0608 |
+
+## Billing Examples
+
+Text model: Calling claude-sonnet-4-6 with 10,000 input tokens and 2,000 output tokens, no cache hit:
+
+```
+10000 / 1,000,000 × 3 + 2000 / 1,000,000 × 15 = $0.06
+```
+
+Text model with explicit cache: Calling claude-haiku-4-5. The first request writes 5,000 tokens to the 5-minute cache tier and outputs 1,000 tokens. The second request hits the cache for 5,000 tokens, with 500 new input tokens and 1,000 output tokens:
+
+```
+First call:  5000 / 1,000,000 × 1.25 (Write·5min) + 1000 / 1,000,000 × 5 = $0.00625 + $0.005 = $0.01125
+Second call: 5000 / 1,000,000 × 0.1 (Hit) + 500 / 1,000,000 × 1 + 1000 / 1,000,000 × 5 = $0.0005 + $0.0005 + $0.005 = $0.006
+```
+
+Text model with implicit cache: Calling gpt-5-2025-08-07 with 10,000 input tokens (of which 6,000 hit the implicit cache) and 2,000 output tokens:
+
+```
+Cached portion:    6000 / 1,000,000 × 0.125 = $0.00075
+Uncached input:    4000 / 1,000,000 × 1.25  = $0.005
+Output:            2000 / 1,000,000 × 10    = $0.02
+Total:                                        $0.02575
+```