@sctg/cline-shared 3.84.0-beta.20260524130712

package/dist/llms/ai-sdk-format.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Sanitizes unpaired/lone Unicode surrogates in text content.
+ *
+ * Lone surrogates (high surrogates without matching low surrogates, or vice versa)
+ * can cause JSON serialization issues and downstream processing errors when sending
+ * text to LLM providers. This function replaces them with the Unicode replacement
+ * character (U+FFFD).
+ *
+ * @param content - The string to sanitize
+ * @returns The string with lone surrogates replaced by U+FFFD
+ */
+export declare function sanitizeSurrogates(content: string): string;
+export type AiSdkFormatterMessageRole = "user" | "assistant" | "tool";
+export type AiSdkFormatterPart = {
+    type: "text";
+    text: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
+} | {
+    type: "reasoning";
+    text: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
+} | {
+    type: "image";
+    image: string | Uint8Array | ArrayBuffer | URL;
+    mediaType?: string;
+} | {
+    type: "file";
+    path: string;
+    content: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerOptions?: Record<string, Record<string, unknown>>;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export interface AiSdkFormatterMessage {
+    role: AiSdkFormatterMessageRole;
+    content: string | AiSdkFormatterPart[];
+}
+export type AiSdkMessagePart = Record<string, unknown>;
+export type AiSdkMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | AiSdkMessagePart[];
+};
+export declare function toAiSdkToolResultOutput(output: unknown, isError?: boolean): Record<string, unknown>;
+export declare function formatMessagesForAiSdk(systemContent: string | AiSdkMessagePart[] | undefined, messages: readonly AiSdkFormatterMessage[], options?: {
+    assistantToolCallArgKey?: "args" | "input";
+}): AiSdkMessage[];

package/dist/llms/gateway.d.ts

@@ -0,0 +1,145 @@
+import type { AgentMessage, AgentModelEvent, AgentToolDefinition } from "../agent";
+import type { BasicLogger } from "../logging/logger";
+import type { ProviderCapability } from "../rpc/runtime";
+import type { ITelemetryService } from "../services/telemetry";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue | undefined;
+};
+export type GatewayModelCapability = "text" | "tools" | "reasoning" | "prompt-cache" | "images" | "audio" | "structured-output";
+export type GatewayPromptCacheStrategy = "anthropic-automatic";
+export type GatewayUsageCostDisplay = "show" | "hide";
+export type GatewayPromptCacheFormat = "anthropic-cache-control";
+export type GatewayReasoningFormat = "anthropic-thinking" | "glm-thinking";
+export type GatewayModelRoute = {
+    matcher: "anthropic-compatible";
+} | {
+    matcher: "model-family";
+    family: string;
+    requiredCapability?: GatewayModelCapability;
+} | {
+    matcher: "model-id";
+    modelId: string;
+    requiredCapability?: GatewayModelCapability;
+};
+export interface GatewayProviderRouting {
+    promptCache?: {
+        format: GatewayPromptCacheFormat;
+        routes: GatewayModelRoute[];
+    };
+    reasoning?: {
+        format: GatewayReasoningFormat;
+        routes: GatewayModelRoute[];
+    };
+}
+export interface GatewayProviderMetadata {
+    promptCacheStrategy?: GatewayPromptCacheStrategy;
+    usageCostDisplay?: GatewayUsageCostDisplay;
+    routing?: GatewayProviderRouting;
+    [key: string]: JsonValue | GatewayProviderRouting | undefined;
+}
+export interface GatewayModelDefinition {
+    id: string;
+    name: string;
+    providerId: string;
+    description?: string;
+    contextWindow?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    capabilities?: readonly GatewayModelCapability[];
+    metadata?: Record<string, JsonValue | undefined>;
+}
+export interface GatewayProviderManifest {
+    id: string;
+    name: string;
+    description?: string;
+    defaultModelId: string;
+    models: readonly GatewayModelDefinition[];
+    capabilities?: readonly ProviderCapability[];
+    env?: readonly ("browser" | "node")[];
+    api?: string;
+    apiKeyEnv?: readonly string[];
+    docsUrl?: string;
+    metadata?: GatewayProviderMetadata;
+}
+export interface GatewayProviderSettings {
+    apiKey?: string;
+    apiKeyResolver?: () => string | undefined | Promise<string | undefined>;
+    apiKeyEnv?: readonly string[];
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    options?: Record<string, unknown>;
+    metadata?: GatewayProviderMetadata;
+}
+export interface GatewayResolvedProviderConfig extends GatewayProviderSettings {
+    providerId: string;
+}
+export interface GatewayProviderConfig extends GatewayProviderSettings {
+    providerId: string;
+    enabled?: boolean;
+    defaultModelId?: string;
+    models?: readonly Omit<GatewayModelDefinition, "providerId">[];
+}
+export interface GatewayModelSelection {
+    providerId: string;
+    modelId?: string;
+}
+export interface GatewayResolvedModel {
+    provider: GatewayProviderManifest;
+    model: GatewayModelDefinition;
+}
+export interface GatewayProviderContext {
+    provider: GatewayProviderManifest;
+    model: GatewayModelDefinition;
+    config: GatewayResolvedProviderConfig;
+    signal?: AbortSignal;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+export interface GatewayStreamRequest {
+    providerId: string;
+    modelId: string;
+    systemPrompt?: string;
+    messages: readonly AgentMessage[];
+    tools?: readonly AgentToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    metadata?: Record<string, unknown>;
+    reasoning?: {
+        enabled?: boolean;
+        effort?: "low" | "medium" | "high";
+        budgetTokens?: number;
+    };
+    signal?: AbortSignal;
+}
+export interface GatewayProvider {
+    stream(request: GatewayStreamRequest, context: GatewayProviderContext): AsyncIterable<AgentModelEvent> | Promise<AsyncIterable<AgentModelEvent>>;
+}
+export type GatewayProviderFactory = (config: GatewayResolvedProviderConfig) => GatewayProvider | Promise<GatewayProvider>;
+export interface GatewayProviderRegistration {
+    manifest: GatewayProviderManifest;
+    defaults?: GatewayProviderSettings;
+    createProvider?: GatewayProviderFactory;
+    loadProvider?: () => Promise<Pick<GatewayProviderRegistration, "createProvider">>;
+}
+export interface GatewayModelHandleOptions {
+    tools?: readonly AgentToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    metadata?: Record<string, unknown>;
+    reasoning?: {
+        enabled?: boolean;
+        effort?: "low" | "medium" | "high";
+        budgetTokens?: number;
+    };
+    signal?: AbortSignal;
+}
+export interface GatewayConfig {
+    builtins?: false | readonly string[];
+    providers?: readonly GatewayProviderRegistration[];
+    providerConfigs?: readonly GatewayProviderConfig[];
+    fetch?: typeof fetch;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}

package/dist/llms/messages.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Message Types
+ *
+ * Standardized message format for input to providers.
+ * This is a simplified, provider-agnostic format that can be
+ * converted to any provider's native format.
+ */
+/**
+ * Message roles
+ */
+export type MessageRole = "user" | "assistant";
+/**
+ * Text content block
+ */
+export interface TextContent {
+    type: "text";
+    text: string;
+    /** Thought signature for this text part (Gemini) */
+    signature?: string;
+}
+/**
+ * File content block for Cline
+ */
+export interface FileContent {
+    type: "file";
+    content: string;
+    /** Absolute Path */
+    path: string;
+    source?: string;
+}
+/**
+ * Image content block
+ */
+export interface ImageContent {
+    type: "image";
+    /** Base64 encoded image data */
+    data: string;
+    /** MIME type (e.g., "image/png", "image/jpeg") */
+    mediaType: string;
+}
+/**
+ * Tool use content block (assistant's tool call)
+ */
+export interface ToolUseContent {
+    type: "tool_use";
+    /** Unique ID for this tool call */
+    id: string;
+    /** Provider-native call ID for this tool call (if available) */
+    call_id?: string;
+    /** Name of the tool being called */
+    name: string;
+    /** Arguments for the tool call */
+    input: Record<string, unknown>;
+    /** Thought signature for this function call part (Gemini) */
+    signature?: string;
+}
+/**
+ * Tool result content block (user's response to tool call)
+ */
+export interface ToolResultContent {
+    type: "tool_result";
+    /** ID of the tool call this is responding to */
+    tool_use_id: string;
+    /** Name of the tool that generated this result */
+    name: string;
+    /** Result content (can be text or error) */
+    content: string | Array<TextContent | ImageContent | FileContent>;
+    /** Whether this result represents an error */
+    is_error?: boolean;
+}
+/**
+ * Thinking/reasoning content block
+ */
+export interface ThinkingContent {
+    type: "thinking";
+    /** The thinking/reasoning text */
+    thinking: string;
+    /** Signature for the thinking block (provider-specific) */
+    signature?: string;
+    /** Provider-native call ID for this reasoning block (if available) */
+    call_id?: string;
+    /** Structured reasoning details that can be replayed for tool-call continuation */
+    details?: unknown[];
+    /** Backward-compatible alias used by some internal processors */
+    summary?: unknown[];
+}
+/**
+ * Redacted thinking content block
+ */
+export interface RedactedThinkingContent {
+    type: "redacted_thinking";
+    /** Encrypted/redacted data */
+    data: string;
+    /** Provider-native call ID for this reasoning block (if available) */
+    call_id?: string;
+}
+/**
+ * Union of all content block types
+ */
+export type ContentBlock = TextContent | ImageContent | ToolUseContent | ToolResultContent | ThinkingContent | FileContent | RedactedThinkingContent;
+/**
+ * A single message in the conversation
+ */
+export interface Message {
+    /** Message role */
+    role: MessageRole;
+    /** Message content - can be a simple string or array of content blocks */
+    content: string | ContentBlock[];
+}
+/**
+ * Extended message with metadata (used for storage/history)
+ */
+export interface MessageWithMetadata extends Message {
+    /** Unique message ID */
+    id?: string;
+    /** Logical agent kind for persisted session/history consumers */
+    agent?: string;
+    /** Concrete session id that owns this persisted message */
+    sessionId?: string;
+    /** Additional message metadata for storage/history consumers */
+    metadata?: Record<string, unknown>;
+    /** Model info at the time of generation */
+    modelInfo?: {
+        id: string;
+        provider: string;
+        family?: string;
+    };
+    /** Token usage metrics */
+    metrics?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        cost?: number;
+    };
+    /** Timestamp of when the message was created */
+    ts?: number;
+}
+/**
+ * Tool definition for native tool calling
+ */
+export interface ToolDefinition {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** JSON Schema for the tool's input parameters */
+    inputSchema: Record<string, unknown>;
+}

package/dist/llms/model-info.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Model Information Types
+ *
+ * Zod schemas and inferred types for model capabilities, pricing,
+ * and metadata. These live in shared so that agent types can reference
+ * ModelInfo without depending on @cline/llms.
+ */
+import { z } from "zod";
+export declare const ApiFormatSchema: z.ZodEnum<{
+    default: "default";
+    "openai-responses": "openai-responses";
+    r1: "r1";
+}>;
+export type ApiFormat = z.infer<typeof ApiFormatSchema>;
+export declare const ApiFormat: {
+    readonly DEFAULT: "default";
+    readonly OPENAI_RESPONSES: "openai-responses";
+    readonly R1: "r1";
+};
+export declare const ModelCapabilitySchema: z.ZodEnum<{
+    images: "images";
+    tools: "tools";
+    streaming: "streaming";
+    "prompt-cache": "prompt-cache";
+    reasoning: "reasoning";
+    "reasoning-effort": "reasoning-effort";
+    "computer-use": "computer-use";
+    "global-endpoint": "global-endpoint";
+    structured_output: "structured_output";
+    temperature: "temperature";
+    files: "files";
+}>;
+export type ModelCapability = z.infer<typeof ModelCapabilitySchema>;
+export declare const ModelStatusSchema: z.ZodEnum<{
+    active: "active";
+    preview: "preview";
+    deprecated: "deprecated";
+    legacy: "legacy";
+}>;
+export type ModelStatus = z.infer<typeof ModelStatusSchema>;
+export declare const ModelPricingSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cacheWrite: z.ZodOptional<z.ZodNumber>;
+    cacheRead: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelPricing = z.infer<typeof ModelPricingSchema>;
+export declare const ThinkingConfigSchema: z.ZodObject<{
+    maxBudget: z.ZodOptional<z.ZodNumber>;
+    outputPrice: z.ZodOptional<z.ZodNumber>;
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+export type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+export declare const ModelMetadataSchema: z.ZodObject<{
+    reasoningDefaultOn: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type ModelMetadata = z.infer<typeof ModelMetadataSchema>;
+export declare const ModelInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    apiFormat: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "openai-responses": "openai-responses";
+        r1: "r1";
+    }>>;
+    systemRole: z.ZodOptional<z.ZodEnum<{
+        system: "system";
+        developer: "developer";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cacheWrite: z.ZodOptional<z.ZodNumber>;
+        cacheRead: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    thinkingConfig: z.ZodOptional<z.ZodObject<{
+        maxBudget: z.ZodOptional<z.ZodNumber>;
+        outputPrice: z.ZodOptional<z.ZodNumber>;
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+        }>>;
+    }, z.core.$strip>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        preview: "preview";
+        deprecated: "deprecated";
+        legacy: "legacy";
+    }>>;
+    deprecationNotice: z.ZodOptional<z.ZodString>;
+    replacedBy: z.ZodOptional<z.ZodString>;
+    releaseDate: z.ZodOptional<z.ZodString>;
+    deprecationDate: z.ZodOptional<z.ZodString>;
+    family: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        reasoningDefaultOn: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type ModelInfo = z.infer<typeof ModelInfoSchema>;

package/dist/llms/reasoning-effort.d.ts

@@ -0,0 +1,21 @@
+export declare const REASONING_EFFORT_RATIOS: {
+    readonly xhigh: 0.95;
+    readonly high: 0.8;
+    readonly medium: 0.5;
+    readonly low: 0.2;
+    readonly minimal: 0.1;
+    readonly none: 0;
+};
+export type ReasoningEffortValue = keyof typeof REASONING_EFFORT_RATIOS;
+export declare const DEFAULT_REASONING_EFFORT: ReasoningEffortValue | undefined;
+export declare function resolveEffectiveReasoningEffort(reasoningEffort?: string, thinking?: boolean): ReasoningEffortValue | undefined;
+export declare function resolveReasoningEffortRatio(effort?: string, options?: {
+    fallbackEffort?: ReasoningEffortValue;
+}): number | undefined;
+export declare function resolveReasoningBudgetFromRatio(options: {
+    effort?: string;
+    maxBudget: number;
+    scaleTokens?: number;
+    minimumBudget?: number;
+    fallbackEffort?: ReasoningEffortValue;
+}): number | undefined;

package/dist/llms/requests.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_REQUEST_HEADERS: Record<string, string>;
+export declare function serializeAbortReason(reason: unknown): unknown;

package/dist/llms/tokens.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Conservative chars-per-token approximation used for compaction triggering
+ * and request-size diagnostics. Uses 3 chars/token (slightly over-counts vs
+ * the conventional 4) so trigger thresholds fire before provider rejection
+ * rather than after.
+ */
+export declare function estimateTokens(chars: number): number;

package/dist/llms/tools.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared tool policy and execution record types.
+ */
+import { z } from "zod";
+export interface ToolPolicy {
+    /**
+     * Whether the tool can be executed at all.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Whether this tool can run without asking the client for approval.
+     * @default true
+     */
+    autoApprove?: boolean;
+}
+/**
+ * Record of a tool call execution
+ */
+export interface ToolCallRecord {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Name of the tool that was called */
+    name: string;
+    /** Input passed to the tool */
+    input: unknown;
+    /** Output returned from the tool (if successful) */
+    output: unknown;
+    /** Error message (if the tool failed) */
+    error?: string;
+    /** Time taken to execute the tool in milliseconds */
+    durationMs: number;
+    /** Timestamp when the tool call started */
+    startedAt: Date;
+    /** Timestamp when the tool call ended */
+    endedAt: Date;
+}
+export interface ToolApprovalRequest {
+    /**
+     * Core/hub runtime session identifier.
+     *
+     * This is the routing and lifecycle id for the task/session that owns the
+     * tool call. Hosts and hub transports use it to deliver approval events to
+     * clients subscribed to that session and to correlate approval responses
+     * with the pending runtime session. It should not be used as the transcript
+     * id for model history.
+     */
+    sessionId: string;
+    /**
+     * Agent instance identifier.
+     *
+     * This identifies the lead or delegated agent that requested the tool call.
+     * It is used for attribution in approval prompts, events, telemetry, and
+     * team/sub-agent flows. It is not a hub routing key and should not be used
+     * to find the owning runtime session.
+     */
+    agentId: string;
+    /**
+     * Agent conversation/transcript identifier.
+     *
+     * This identifies the model conversation that produced the tool call. Tools,
+     * hooks, telemetry, and persisted session metadata use it to correlate work
+     * with the agent's message history. It is contextual data, not the hub event
+     * routing key.
+     */
+    conversationId: string;
+    iteration: number;
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    policy: ToolPolicy;
+}
+export interface ToolApprovalResult {
+    approved: boolean;
+    reason?: string;
+}
+export declare const ToolCallRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    startedAt: z.ZodDate;
+    endedAt: z.ZodDate;
+}, z.core.$strip>;

package/dist/logging/logger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cross-package logging surface for hosts that inject their own logger (for example `pino` or the VS Code API).
+ *
+ * {@link BasicLogger.debug} is for verbose diagnostics (hosts typically gate this behind a debug log level).
+ * {@link BasicLogger.log} is the primary channel for operational messages that are not errors.
+ * {@link BasicLogger.error} is optional; when omitted, hosts may route failures through {@link BasicLogger.log}
+ * with {@link BasicLogMetadata.severity} `"error"` or handle errors elsewhere.
+ *
+ * Use {@link noopBasicLogger} when you need a fully-defined no-op implementation.
+ */
+/**
+ * Optional structured fields used across the SDK and recommended for host log backends.
+ * Callers may add other keys freely; these names are the shared convention for cross-component queries.
+ */
+export interface BasicLogMetadata extends Record<string, unknown> {
+    sessionId?: string;
+    runId?: string;
+    providerId?: string;
+    toolName?: string;
+    durationMs?: number;
+    /**
+     * When using {@link BasicLogger.log}, disambiguates severity for backends that map a single `log`
+     * method onto multiple output levels (for example Pino `info` vs `warn`).
+     */
+    severity?: "info" | "warn" | "error";
+}
+export interface BasicLogger {
+    /** Verbose diagnostics; hosts should no-op or filter when not in debug mode. */
+    debug: (message: string, metadata?: BasicLogMetadata) => void;
+    /** Operational messages (replaces former `info` / non-error `warn` split). */
+    log: (message: string, metadata?: BasicLogMetadata) => void;
+    error?: (message: string, metadata?: BasicLogMetadata & {
+        error?: unknown;
+    }) => void;
+}
+/** All levels implemented as no-ops; safe default when no logger is injected. */
+export declare const noopBasicLogger: BasicLogger;

package/dist/parse/error.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function getErrorCode(error: unknown): string;

package/dist/parse/headers/utils.d.ts

@@ -0,0 +1 @@
+export declare function parseKeyPairsIntoRecord(value?: string): Record<string, string>;

package/dist/parse/json.d.ts

@@ -0,0 +1,3 @@
+export declare function parseJsonStream(input: unknown): unknown;
+export declare function safeJsonStringify(input: unknown): string;
+export declare function safeJsonParse<T>(raw: string): T | undefined;

package/dist/parse/shell.d.ts

@@ -0,0 +1,2 @@
+export declare function getDefaultShell(platform: string): string;
+export declare function getShellArgs(shell: string, command: string): string[];

package/dist/parse/string.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeFileName(value: string): string;
+export declare function truncateStr(str: string, maxLen: number): string;
+export declare function truncateSplit(str?: string, splitBy?: string, maxLen?: number): string;
+export declare function maskSecret(value: string): string;

package/dist/parse/time.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parses a date string and returns a human-readable format.
+ * If the input is invalid, it returns the original string or a placeholder.
+ *
+ * @param dateStr - The date string to parse.
+ * @returns A human-readable date string or the original input if invalid.
+ */
+export declare function formatHumanReadableDate(dateStr?: string): string;
+export declare function formatUptime(ms: number): string;

package/dist/parse/zod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Zod Utilities
+ *
+ * Helper functions for working with Zod schemas.
+ */
+import { z } from "zod";
+/**
+ * Validate input using a Zod schema
+ * Throws a formatted error if validation fails
+ */
+export declare function validateWithZod<T>(schema: z.ZodType<T>, input: unknown): T;
+export declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;