export interface SimpleStreamOptions extends StreamOptions {
	/** Provider-neutral tool selection for simple requests. When omitted, adapters use provider-specific behavior. */
	toolChoice?: ToolChoice;
	reasoning?: ThinkingLevel;
	/** Ask a capable provider to return a durable handle and continue the request asynchronously. */
	deferred?: boolean | { window?: "15m" | "1h" | "24h" };
	/** Custom token budgets for thinking levels (token-based providers only) */
	thinkingBudgets?: ThinkingBudgets;
}

export interface ApiOptionsMap {
	"anthropic-messages": AnthropicOptions;
	"openai-completions": OpenAICompletionsOptions;
	"openai-responses": OpenAIResponsesOptions;
	"openai-codex-responses": OpenAICodexResponsesOptions;
	"azure-openai-responses": AzureOpenAIResponsesOptions;
	"google-generative-ai": GoogleOptions;
	"google-vertex": GoogleVertexOptions;
	"mistral-conversations": MistralOptions;
	"bedrock-converse-stream": BedrockOptions;
	"pi-messages": PiMessagesOptions;
}

export type ApiStreamOptions<TApi extends Api> = TApi extends keyof ApiOptionsMap
	? ApiOptionsMap[TApi]
	: StreamOptions & Record<string, unknown>;

class ModelsImpl {
	async completeSimple(
		model: Model<Api>,
		context: Context,
		options?: ModelsSimpleStreamOptions,
	): Promise<AssistantMessage> {
		return this.streamSimple(model, context, options).result();
	}
}

import { createConnection, responseText } from "./connection.js"

const { models, model } = createConnection()
const stream = models.streamSimple(
  model,
  {
    messages: [
      { role: "user", content: "简要解释数组索引，并给一个例子。", timestamp: Date.now() },
    ],
  },
  { signal: AbortSignal.timeout(30_000), maxTokens: 512 },
)
for await (const event of stream) {
  if (event.type === "text_delta") {
    process.stdout.write(event.delta)
  }
  if (event.type === "error") {
    console.error("\n生成状态：", event.reason)
  }
}
const final = await stream.result()
responseText(final)
console.log("\n结束原因：", final.stopReason)
console.log("用量：", final.usage)

node --env-file=.env --import tsx src/stream-response.ts

export interface Context {
	systemPrompt?: string;
	messages: Message[];
	tools?: Tool[];
}

/**
 * Request input accepted by the public stream entry points (`Models.stream()`,
 * `streamSimple()`, ...). `systemPrompt` and `tools` are shorthand for a leading
 * system message; `normalizeContext()` folds them into one before the request
 * reaches a provider.
 */

export type TranscriptContext = {
	messages: Message[];
	readonly [transcriptContextBrand]: true;
};

export type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";

export type Transport = "sse" | "websocket" | "websocket-cached" | "auto";

interface StreamOptions extends ProviderRequestOptions<Model<Api>> {
	/**
	 * Preferred transport for providers that support multiple transports.
	 * Providers that do not support this option ignore it.
	 */
	transport?: Transport;
	// ...
}

appendAssistantMessageDiagnostic(
	output,
	createAssistantMessageDiagnostic("provider_transport_failure", error, {
		configuredTransport: transport,
		...(websocketStarted ? {} : { fallbackTransport: "sse" }),
		eventsEmitted: websocketStarted,
		phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
		requestBytes: new TextEncoder().encode(bodyJson).byteLength,
	}),
);
recordWebSocketFailure(cacheSessionId, error);
if (websocketStarted) {
	throw error;
}
recordWebSocketSseFallback(cacheSessionId);
break;

interface StreamOptions extends ProviderRequestOptions<Model<Api>> {
	/** WebSocket connect timeout in milliseconds for providers that support WebSocket transports. This covers the connection/open handshake only; stream idleness after connection uses timeoutMs. */
	websocketConnectTimeoutMs?: number;

	/** HTTP request timeout in milliseconds for providers/SDKs that support it. For example, OpenAI and Anthropic SDK clients default to 10 minutes. */
	timeoutMs?: number;

	/** Maximum retry attempts for providers/SDKs that support client-side retries. For example, OpenAI and Anthropic SDK clients default to 2. */
	maxRetries?: number;

	/**
	 * Maximum delay in milliseconds to wait for a retry when the server requests a long wait.
	 * If the server's requested delay exceeds this value, the request fails immediately with an error
	 * containing the requested delay, allowing higher-level retry logic to handle it with user visibility.
	 * Default: 60000 (60 seconds). Set to 0 to disable the cap.
	 */
	maxRetryDelayMs?: number;
	// ...
}

export interface Usage {
	input: number;
	output: number;
	cacheRead: number;
	cacheWrite: number;
	/** Subset of `cacheWrite` written with 1h retention. Only Anthropic reports this split. */
	cacheWrite1h?: number;
	/**
	 * Reasoning/thinking tokens, when the provider reports them. This is a subset of
	 * `output`: `output` already includes these tokens. Set to a number (possibly 0) by
	 * providers that expose a reasoning breakdown; left undefined by providers that don't.
	 */
	reasoning?: number;
	totalTokens: number;
	cost: {
		input: number;
		output: number;
		cacheRead: number;
		cacheWrite: number;
		/** Best available total: provider-reported billed cost when supported, otherwise the catalog estimate. */
		total: number;
		/** True when `total` is the billed cost reported by the provider. False when it is a catalog estimate; absent also means false. */
		totalFromProvider?: boolean;
	};
}

export function calculateCost(model: AnyModel, usage: Usage): Usage["cost"] {
	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
	let rates: ModelCostRates = model.cost;
	let matchedThreshold = -1;
	for (const tier of model.cost.tiers ?? []) {
		if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
			rates = tier;
			matchedThreshold = tier.inputTokensAbove;
		}
	}
	// Anthropic charges 2x base input for 1h cache writes.
	const longWrite = usage.cacheWrite1h ?? 0;
	const shortWrite = usage.cacheWrite - longWrite;
	usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1000000;
	// ... 其余 cost 分项 ...
}

const CHARS_PER_TOKEN = 3.5;
const ESTIMATED_IMAGE_CHARS = 4800;

export function estimateTextTokens(text: string): number {
	return Math.ceil(text.length / CHARS_PER_TOKEN);
}