@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.6

package/dist/tool-system/context.d.ts

@@ -16,8 +16,37 @@ import type { LLMConfig, StreamCallback } from "../types.js";
 import type { ModelPool } from "../llm/model-pool.js";
 import type { ToolRegistry } from "./registry.js";
 import type { AgentPresetName } from "../preset/index.js";
-/** Function the host UI / server uses to ask the user a question. */
-export type AskUserFn = (question: string) => Promise<string>;
+/** One choice in a multiple-choice AskUserQuestion. */
+export interface AskUserChoice {
+    label: string;
+    description: string;
+}
+/**
+ * Optional rendering hints / multiple-choice options carried alongside the
+ * question. Implementations may ignore unknown fields — they're additive.
+ */
+export interface AskUserOptions {
+    /** Short chip-style label (≤12 chars) shown above the question. */
+    header?: string;
+    /** Multiple-choice options. When omitted, the UI falls back to free-text. */
+    options?: AskUserChoice[];
+    /** Allow the user to pick more than one option. Defaults to false. */
+    multiSelect?: boolean;
+}
+/**
+ * Function the host UI / server uses to ask the user a question.
+ *
+ * Second argument is optional for backwards compatibility — callers that
+ * only need free text can omit it; backends that don't support options
+ * should ignore the field and prompt for free text.
+ *
+ * Return value:
+ *   - Free-text mode: the user's typed answer (or "(user declined to answer)").
+ *   - Multiple-choice mode: the selected label, or comma-separated labels for
+ *     multiSelect, or "Other: <typed>" when the user picks the implicit
+ *     Other... entry.
+ */
+export type AskUserFn = (question: string, opts?: AskUserOptions) => Promise<string>;
 /** Spawn a sub-agent. Returns the produced text or throws. */
 export interface SubAgentSpawnRequest {
     agentId: string;

package/dist/tool-system/executor.d.ts

@@ -7,6 +7,7 @@ import { ToolRegistry } from "./registry.js";
 import { PermissionClassifier } from "./permission.js";
 import { logger as rootLogger } from "../logging/logger.js";
 import type { ToolContext } from "./context.js";
+import type { InvestigationGuard } from "./investigation-guard.js";
 type Logger = typeof rootLogger;
 export declare class ToolExecutor {
     private readonly registry;
@@ -21,7 +22,10 @@ export declare class ToolExecutor {
      * (tests, ad-hoc tool runs) still write log lines, just without turn tags.
      */
     private log;
+    private guard?;
     constructor(registry: ToolRegistry, permission: PermissionClassifier, hooks: HookRegistry);
+    setInvestigationGuard(guard: InvestigationGuard | undefined): void;
+    getInvestigationGuard(): InvestigationGuard | undefined;
     /** Set the abort signal for cascading cancellation. */
     setSignal(signal?: AbortSignal): void;
     /** Set the per-Engine ToolContext (askUser, llmConfig, modelPool, etc.). */

package/dist/tool-system/investigation-guard.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Investigation Guard — runtime enforcement of read budgets.
+ *
+ * Background: prompt rules in coding.md ("never re-read the same file",
+ * "after ~3 read-only calls, change strategy") describe a behavior the model
+ * frequently violates under context pressure. This module turns those soft
+ * rules into in-loop reminders/blocks delivered through tool results.
+ *
+ * Three independent counters share one guard instance per Engine:
+ *   A) dedupe          — same Read offset hit ≥2 times → reminder; ≥3 times → block
+ *   B) read-budget     — N consecutive read-only tools with no side-effecting
+ *                        tool in between → reminder on the next read
+ *   C) silent turns    — N consecutive turns of only read-only tools with no
+ *                        text output → injected into the *next* turn's user
+ *                        message by turn-loop (the guard just tracks state).
+ *
+ * Everything decays naturally on any write/Bash/AskUser tool (state reset).
+ */
+import type { ToolCall, ToolResult } from "../types.js";
+export interface GuardDecision {
+    block?: string;
+    prepend?: string;
+}
+export declare class InvestigationGuard {
+    private readHistory;
+    private consecutiveReads;
+    private silentTurns;
+    private turnHasText;
+    private turnHasSideEffect;
+    private lastReminderSilent;
+    /**
+     * Soft mode replaces hard blocks (3rd-read dedupe) with a stronger
+     * reminder. Used in headless runs (`code-shell run …`) where there is
+     * no human to retry the task, so an unattended automation should not
+     * be killed by the guard — it should still get the signal to change
+     * strategy, but the tool call goes through.
+     */
+    private softMode;
+    setSoftMode(soft: boolean): void;
+    preToolCheck(call: ToolCall): GuardDecision | undefined;
+    noteText(text: string | undefined): void;
+    noteToolResult(_call: ToolCall, _result: ToolResult): void;
+    turnEnded(turnNumber: number): string | undefined;
+    private isMutatingTool;
+    private buildKey;
+}

package/dist/types.d.ts

@@ -65,7 +65,14 @@ export interface TranscriptEvent {
     turnNumber: number;
     data: Record<string, unknown>;
 }
-export type SessionStatus = "active" | "paused" | "completed" | "errored";
+/**
+ * Session lifecycle state persisted in state.json. `"active"` means a run is
+ * currently in flight (or was, at the moment of the last heartbeat). All other
+ * values match the {@link TerminalReason} the last run returned, so callers
+ * can distinguish a user-cancelled session (`"aborted_streaming"`) from an
+ * actual error (`"model_error"`, `"prompt_too_long"`, ...).
+ */
+export type SessionStatus = "active" | "paused" | TerminalReason;
 export interface SessionState {
     sessionId: string;
     cwd: string;
@@ -219,10 +226,14 @@ export type StreamEvent = {
     summary: string;
 } | {
     type: "context_compact";
-    strategy: "summary" | "window" | "snip" | "emergency";
+    strategy: "micro" | "summary" | "window" | "snip" | "emergency";
     before: number;
     after: number;
     agentId?: string;
+} | {
+    type: "usage_update";
+    promptTokens: number;
+    agentId?: string;
 };
 export type StreamCallback = (event: StreamEvent) => void | Promise<void>;
 export interface LLMConfig {

package/dist/ui/components/AskUserPrompt.d.ts

@@ -1,7 +1,14 @@
+interface Choice {
+    label: string;
+    description: string;
+}
 interface AskUserPromptProps {
     question: string;
+    header?: string;
+    options?: Choice[];
+    multiSelect?: boolean;
     onAnswer: (answer: string) => void;
     onCancel: () => void;
 }
-export declare function AskUserPrompt({ question, onAnswer, onCancel }: AskUserPromptProps): import("react/jsx-runtime").JSX.Element;
+export declare function AskUserPrompt({ question, header, options, multiSelect, onAnswer, onCancel, }: AskUserPromptProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/ui/components/DiffLine.d.ts

@@ -0,0 +1,33 @@
+export type DiffKind = "add" | "remove" | "hunk" | "context";
+interface DiffLineProps {
+    kind: DiffKind;
+    /** Raw text WITHOUT the `+ ` / `- ` prefix — DiffLine renders the marker. */
+    text: string;
+    /**
+     * Left indent applied before the marker (and before the gutter, if any).
+     * Defaults to 0; ToolCallResult passes its own padding so diff blocks
+     * line up under the `✓ ToolName` header.
+     */
+    indent?: number;
+    /**
+     * Optional dim leading glyph rendered before the colored band (e.g. the
+     * `⎿ ` connector ToolCallResult uses to group output under its header).
+     * Padding to terminal width accounts for the glyph so the band still
+     * extends to the right edge.
+     */
+    gutter?: string;
+}
+export declare function DiffLine({ kind, text, indent, gutter }: DiffLineProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Classify a raw diff text line. Matches `+\s` / `-\s` (so `+x` identifiers
+ * and `+++ / ---` file headers don't trip it), `@@` hunk markers, and falls
+ * through to context.
+ *
+ * Returns the kind and the text with its marker stripped (since `<DiffLine>`
+ * re-renders the marker itself).
+ */
+export declare function classifyDiffLine(raw: string): {
+    kind: DiffKind;
+    text: string;
+};
+export {};

package/dist/ui/components/ModelManager.d.ts

@@ -15,10 +15,29 @@ export type ArenaParticipantEntry = {
     kind: "object";
     label: string;
 };
+/**
+ * Row data shown in the Providers tab. Counts/timestamps are derived by the
+ * parent from settings.providers[] + the model cache so this component stays
+ * presentational.
+ */
+export interface ProviderManagerEntry {
+    key: string;
+    label: string;
+    kind: string;
+    modelCount: number;
+    cachedModels?: number;
+    cachedAt?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    protocol?: string;
+    modelsPath?: string;
+}
 interface ModelManagerProps {
     entries: ProtocolModelEntry[];
     snapshot: SnapshotInfo;
     arenaParticipants: ArenaParticipantEntry[];
+    /** Providers configured in settings.providers[] (Task 11+). */
+    providers?: ProviderManagerEntry[];
     /** Activate a model. */
     onSwitch: (key: string) => Promise<void>;
     /** Trigger an OpenRouter snapshot refresh. */
@@ -29,7 +48,21 @@ interface ModelManagerProps {
     }>;
     /** Persist updated participant list (string[]) to settings. */
     onSaveArena: (participants: string[]) => Promise<void>;
+    /** Open the parent-rendered ProviderModelFlow (covers both add-provider and add-model). */
+    onOpenFlow?: () => void;
+    /** Force-refresh a provider's cached model list. */
+    onRefreshProvider?: (key: string) => Promise<{
+        count: number;
+        error?: string;
+    }>;
+    /** Delete a provider (blocked if any model references it). */
+    onDeleteProvider?: (key: string) => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** Delete a model entry. */
+    onDeleteModel?: (key: string) => Promise<void>;
     onClose: () => void;
 }
-export declare function ModelManager({ entries, snapshot, arenaParticipants, onSwitch, onSync, onSaveArena, onClose, }: ModelManagerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ModelManager({ entries, snapshot, arenaParticipants, providers, onSwitch, onSync, onSaveArena, onOpenFlow, onRefreshProvider, onDeleteProvider, onDeleteModel, onClose, }: ModelManagerProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/ui/components/OnboardingPrompt.d.ts

@@ -1,7 +1,16 @@
 import { type OnboardingResult } from "../../cli/onboarding.js";
+import type { ProviderConfig } from "../../llm/provider-catalog.js";
 interface OnboardingPromptProps {
     onComplete: (result: OnboardingResult) => void;
     onCancel: () => void;
+    /** Existing providers — surfaces "Use existing" in the flow's first step.
+     *  Optional: empty by default (first-run case). */
+    existingProviders?: ProviderConfig[];
+    /** Existing model aliases — used by the flow to derive unique aliases. */
+    existingModelKeys?: string[];
+    /** Model ids already in settings.models[] — used by the flow to disable
+     *  rows for models the user has already added. */
+    existingModelIds?: string[];
 }
-export declare function OnboardingPrompt({ onComplete, onCancel }: OnboardingPromptProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function OnboardingPrompt({ onComplete, onCancel, existingProviders, existingModelKeys, existingModelIds, }: OnboardingPromptProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/ui/components/ProviderModelFlow.d.ts

@@ -0,0 +1,58 @@
+import { type ProviderKindName } from "../../llm/provider-kinds.js";
+import type { ProviderConfig } from "../../llm/provider-catalog.js";
+export interface EnvKeyHint {
+    envKey: string;
+    apiKey: string;
+    kindHint: ProviderKindName;
+}
+export interface FlowResult {
+    addedProvider?: ProviderConfig;
+    /**
+     * Self-describing model entries — credentials are duplicated from the
+     * provider on purpose. The engine reads these without a ProviderCatalog
+     * round-trip; providers[] is kept only as a credential source for the
+     * wizard's future "add model to existing provider" flow.
+     */
+    addedModels: Array<{
+        key: string;
+        label?: string;
+        providerKey: string;
+        /** LLM client/protocol ("openai"/"anthropic"). */
+        protocol: string;
+        /** Legacy mirror of `protocol` for downstream readers that still query it. */
+        provider: string;
+        model: string;
+        baseUrl: string;
+        apiKey?: string;
+        maxContextTokens?: number;
+        maxOutputTokens?: number;
+    }>;
+    activeModelKey?: string;
+}
+export interface ProviderModelFlowProps {
+    existingProviders: ProviderConfig[];
+    existingModelKeys: string[];
+    /**
+     * Model ids (e.g. "deepseek-v4-pro") already present in settings.models[]
+     * under SOME provider. The fetch step uses this to disable rows for
+     * models the user has already added — keeps the menu informative (shows
+     * the full catalog) without letting the user re-add duplicates that
+     * appendOnboardingResult would silently drop.
+     */
+    existingModelIds?: string[];
+    detectedEnvKeys?: EnvKeyHint[];
+    switchToNewModelOnFinish: boolean;
+    onFinish: (r: FlowResult) => void;
+    onCancel: () => void;
+}
+/**
+ * Pool-key generator for wizard-added models. Format is `provider-model` so
+ * the alias self-identifies (e.g. "deepseek-v4-pro", not just "v4-pro" or
+ * "deepseek"). Collisions get a numeric suffix.
+ *
+ * If the model id already starts with `<provider>-`, we don't duplicate.
+ */
+export declare function deriveModelAlias(modelId: string, used: string[], providerKind?: string): string;
+export declare function deriveProviderKey(kindOrUrl: string, used: string[]): string;
+export declare function validateAlias(alias: string, used: string[]): string | null;
+export declare function ProviderModelFlow({ existingProviders, existingModelKeys, existingModelIds, detectedEnvKeys, switchToNewModelOnFinish, onFinish, onCancel, }: ProviderModelFlowProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/UpdateBanner.d.ts

@@ -0,0 +1 @@
+export declare function UpdateBanner(): import("react/jsx-runtime").JSX.Element | null;

package/dist/updater-I7QBW4DP.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _chunkMV7YI4WOcjs = require('./chunk-MV7YI4WO.cjs');
+require('./chunk-KS3RYAYL.cjs');
+
+
+
+
+
+
+
+exports.__internal = _chunkMV7YI4WOcjs.__internal; exports.checkForUpdate = _chunkMV7YI4WOcjs.checkForUpdate; exports.getAutoUpdateDisabledReason = _chunkMV7YI4WOcjs.getAutoUpdateDisabledReason; exports.getCurrentVersion = _chunkMV7YI4WOcjs.getCurrentVersion; exports.getUpdateAvailable = _chunkMV7YI4WOcjs.getUpdateAvailable; exports.scheduleAutoInstallOnExit = _chunkMV7YI4WOcjs.scheduleAutoInstallOnExit;

package/dist/updater-NVME5S3Z.js

@@ -0,0 +1,17 @@
+import {
+  __internal,
+  checkForUpdate,
+  getAutoUpdateDisabledReason,
+  getCurrentVersion,
+  getUpdateAvailable,
+  scheduleAutoInstallOnExit
+} from "./chunk-KE4EQOWA.js";
+import "./chunk-MD32R22I.js";
+export {
+  __internal,
+  checkForUpdate,
+  getAutoUpdateDisabledReason,
+  getCurrentVersion,
+  getUpdateAvailable,
+  scheduleAutoInstallOnExit
+};

package/dist/utils/semver.d.ts

@@ -2,4 +2,5 @@
  * Shim for CC's utils/semver — re-exports semver comparison helpers.
  */
 export declare function gte(a: string, b: string): boolean;
+export declare function gt(a: string, b: string): boolean;
 export declare function lt(a: string, b: string): boolean;

package/dist/utils/task-sanitizer.d.ts

@@ -0,0 +1,6 @@
+export interface NoiseResult {
+    isNoise: boolean;
+    reason: string;
+    cleaned: string;
+}
+export declare function detectPastedNoise(task: string): NoiseResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.6",
   "description": "Code Shell — general-purpose agent orchestration framework with a terminal coding preset",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -62,6 +62,7 @@
   "files": [
     "dist",
     "scripts/check-node.cjs",
+    "skills-builtin",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/skills-builtin/codeshell-help.md

@@ -0,0 +1,135 @@
+---
+name: codeshell-help
+description: Use when the user asks how to use code-shell itself — slash commands, login/model setup, settings.json keys, hooks, MCP servers, debugging flags, or "how do I X in code-shell". Skip for general programming questions.
+when_to_use: User asks about code-shell features, configuration, slash commands, or runtime behavior. Not for code questions in the user's own project.
+---
+
+# Using code-shell
+
+You are running inside **code-shell**, a terminal coding agent. This skill answers user questions about code-shell itself. Quote sections directly where helpful. If a topic isn't covered, say so — don't invent commands.
+
+## Getting started
+
+- `code-shell` — start an interactive REPL in the current directory.
+- `code-shell run "<prompt>"` — one-shot non-interactive run, prints final answer and exits.
+- `code-shell runs <sid>` — resume a saved session by id.
+- First launch shows an onboarding flow that walks through provider + model setup.
+
+## Slash commands (run inside the REPL)
+
+Type `/` and the menu appears. The full list:
+
+### Core
+- `/help` — show the slash menu.
+- `/exit` — quit the REPL.
+- `/clear` — clear the conversation (keeps session id).
+- `/compact` — manually trigger context compaction.
+- `/status` — current model, effort, token usage, working dir.
+- `/version` — code-shell version.
+- `/cost` — token cost summary for the session.
+- `/sid` — print the current session id.
+- `/session` — open the session picker.
+- `/resume` — resume the most recent session.
+- `/diff` — show working-tree diff.
+- `/tasks` — current task list (TaskCreate/TaskUpdate state).
+- `/tools` — list available tools.
+- `/memory` — open the per-project memory file.
+- `/export markdown` — export the current conversation to a markdown file.
+
+### Models / providers
+- `/login` — add a new provider + model via the unified ProviderModelFlow.
+- `/logout` — remove a provider's stored credentials.
+- `/model` — quick-switch the active model.
+- `/models` — open the ModelManager (add, refresh, delete providers and models).
+
+### Configuration
+- `/config` — open `settings.json` for the active scope.
+- `/permissions` — manage tool permission rules.
+- `/hooks` — list hooks configured in settings.
+- `/mcp` — list and manage MCP servers.
+- `/skills` — list discovered skills.
+- `/effort` — set reasoning effort (low / medium / high) for reasoning models.
+
+### Git / review
+- `/commit` — agent drafts a commit from staged changes.
+- `/branch` — branch operations.
+- `/review` — review pending changes.
+- `/pr-comments` — fetch GitHub PR comments.
+- `/autofix-pr` — apply review suggestions.
+- `/security-review` — run a security-focused review of pending changes.
+
+### Misc
+- `/init` — scaffold or refresh `CODESHELL.md` / project rules based on repo state.
+- `/copy` — copy last response to clipboard.
+- `/undo` — undo the most recent file edit done by the agent.
+- `/update` — check for and install code-shell updates (auto-installs on exit when npm prefix is writable).
+- `/log` — open the session log file.
+- `/files` — list files the agent has touched this session.
+- `/release-notes` — show CHANGELOG for the running version.
+- `/feedback` — open the feedback URL.
+- `/voice` — voice input (if enabled).
+
+## Provider + model setup
+
+code-shell uses a **two-layer config**: `providers[]` holds credentials and base URLs; `models[]` references a provider by key.
+
+- New users: `/login` runs the full wizard — pick provider kind (anthropic / openai / openrouter / deepseek / custom), enter API key, optional base URL, then pick a model from the fetched list.
+- Existing users with the legacy flat `models[]` shape: auto-migrated on startup with a `.bak` snapshot written next to `settings.json`.
+- Refresh a provider's model list: `/models` → select provider → Refresh. Cached for 7 days under `~/.code-shell/cache/`.
+
+## settings.json — key fields
+
+Located at `~/.code-shell/settings.json` (user scope) or `.code-shell/settings.json` (project scope, takes precedence).
+
+- `providers[]` — `[{ key, kind, baseUrl, apiKey }]`. Source of credentials.
+- `models[]` — `[{ id, providerKey, displayName, contextLength, ... }]`.
+- `model` — the default active model id.
+- `autoUpdates` — `false` disables the background updater.
+- `permissions` — allow/deny rules for the Bash tool and others.
+- `hooks` — shell commands to run on events (SessionStart, PreToolUse, etc.).
+- `mcpServers` — `{ name: { command, args, env } }` map of MCP servers.
+
+## Hooks
+
+Hooks are shell commands the harness runs on events. Configured in `settings.json` under `hooks`. Common events: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `Stop`. Use them for automated behaviors ("each time X happens, run Y") — memory or preferences can't do this because the model doesn't fire actions on schedule, the harness does.
+
+## MCP servers
+
+`code-shell` speaks the Model Context Protocol. Add servers in `settings.json` under `mcpServers`. Each entry is a stdio command code-shell spawns; its tools/resources become available to the agent automatically. List with `/mcp`.
+
+## Debugging
+
+- `CODE_SHELL_DEV=1 code-shell` — dev mode: enables the per-session verbose recorder (JSONL traces under `log/<date>/session-<sid>.jsonl`, 7-day retention), disables auto-update, shows extra UI.
+- `--debug` flag has the same effect as `CODE_SHELL_DEV=1`.
+- Logs: `~/.code-shell/log/` for general logs; per-session JSONL traces appear there when dev mode is on.
+- Investigation guard: re-reading the same file 3× is hard-blocked. 4+ consecutive read-only tool calls inject a "change strategy" reminder. This is intentional — break the loop, don't fight it.
+- Update install log: `~/.code-shell/update.log`.
+
+## Memory
+
+code-shell has a per-project memory system at `.code-shell/memory/` (relative to project root) and a global one at `~/.code-shell/memory/`. The `MEMORY.md` index is auto-loaded into context every session. Individual memory files are loaded on demand. Edit with `/memory` or directly.
+
+## Skills
+
+Skills are markdown files with frontmatter that get discovered automatically. Locations scanned:
+- `<cwd>/.code-shell/skills/` — project-level
+- `<cwd>/.claude/skills/` — project-level (Claude Code compat)
+- `~/.code-shell/skills/` — user-level
+- `~/.claude/skills/` — user-level (Claude Code compat)
+- Built-in skills shipped with the package (e.g. this one).
+
+List discovered skills with `/skills`. Invoke a skill with the `Skill` tool by name. Frontmatter `description` tells the model when to use it.
+
+## Common questions
+
+**"How do I switch models?"** — `/model <id>` or pick from `/models`.
+
+**"How do I add a new provider?"** — `/login`, then follow the wizard. Or edit `settings.json` `providers[]` directly.
+
+**"Why is auto-update not working?"** — `/update` shows the disabled reason. Common: dev build, `DISABLE_AUTOUPDATER=1`, `settings.autoUpdates: false`, or the npm global prefix isn't writable (use the shown `sudo` command).
+
+**"Where's my session saved?"** — `~/.code-shell/sessions/<sid>/`. State, messages, and tool results all there.
+
+**"How do I see what tools an agent has?"** — `/tools`.
+
+**"How do I limit what Bash commands the agent can run?"** — `/permissions` or edit `settings.permissions` directly.

package/dist/anthropic-P5VETAFI.cjs

@@ -1,10 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkBUJ5KYCIcjs = require('./chunk-BUJ5KYCI.cjs');
-require('./chunk-GZBD6QRS.cjs');
-require('./chunk-EL2RL5DG.cjs');
-require('./chunk-JHNCK7JP.cjs');
-require('./chunk-IJSHQGMP.cjs');
-
-
-exports.AnthropicClient = _chunkBUJ5KYCIcjs.AnthropicClient;

package/dist/anthropic-W2GU3D76.js

@@ -1,10 +0,0 @@
-import {
-  AnthropicClient
-} from "./chunk-M2SVOKC6.js";
-import "./chunk-SCDKLTN3.js";
-import "./chunk-FUOKLKR2.js";
-import "./chunk-ZRVPCXI7.js";
-import "./chunk-DI7RDLOS.js";
-export {
-  AnthropicClient
-};