@cspeach/cli 0.6.0

package/dist/agent/maybe-build-project-context.js

@@ -0,0 +1,126 @@
+/**
+ * Phase 2 of Track B — opt-in project-context prompt enrichment.
+ *
+ * Builds the rendered <project_context> block when CSPEACH_PROJECT_CONTEXT
+ * is set to "on", otherwise returns an empty string. Caches the rendered
+ * output at module scope so the project-context computation runs at most
+ * once per CLI process.
+ *
+ * Default OFF. With the flag unset (the production state for every existing
+ * user) this returns '' on every call — the loop's enrichment path then
+ * behaves identically to today.
+ *
+ * Out of scope for Phase 2 (deferred):
+ *
+ *  - **Telemetry emission.** The technical plan calls for tracking
+ *    flag-on vs flag-off token usage and tool-call deltas. CSPeach has
+ *    a telemetry config field but no actual emitter pluggable into the
+ *    loop today. Building one is its own design decision; surface
+ *    counts via existing session.usage / session.toolCalls when those
+ *    aggregate paths exist.
+ *
+ *  - **SapConnectionContext population.** getProjectContext accepts an
+ *    optional sapConnection argument; the REPL has the sapAlias today
+ *    but doesn't construct the full SapConnectionContext object.
+ *    Phase 2.1 follow-up: build an adapter from session state +
+ *    getSapSystemInfo to populate this when an alias is present.
+ *
+ *  - **On-demand refresh tool.** Decision 3 (RESOLVED 2026-05-10)
+ *    parks the project_context_get / project_context_refresh tool to
+ *    Phase 3. Today the cache is process-lifetime; users get a fresh
+ *    context next CLI invocation.
+ */
+import { getProjectContext, renderProjectContext } from '../project-context/index.js';
+/**
+ * The env-var name that gates this enrichment. Treated case-insensitively
+ * but value comparison is exact ("on" only — anything else is OFF).
+ *
+ * Exported so tests can reference it without hardcoding a string.
+ */
+export const PROJECT_CONTEXT_ENV_FLAG = 'CSPEACH_PROJECT_CONTEXT';
+/**
+ * Module-scope cache. The cached value is the rendered block (possibly
+ * empty when detection produced nothing actionable). `null` means
+ * "never computed in this process." A subsequent call short-circuits
+ * to whatever was cached the first time.
+ */
+let cachedBlock = null;
+/**
+ * One-shot warning latch — flips true after the first time we surface
+ * a never-throws contract violation to stderr. Subsequent errors are
+ * still caught + cached as empty, but we don't spam the console.
+ */
+let warnedOnce = false;
+/**
+ * Public cache reset. Phase 3's `project_context_refresh` tool will
+ * call this to invalidate a stale cache without restarting the CLI
+ * (e.g. after a `file_write` that creates a new controller). Also
+ * resets the one-shot warning latch so a fresh attempt can warn anew
+ * if it errors.
+ */
+export function resetProjectContextCache() {
+    cachedBlock = null;
+    warnedOnce = false;
+}
+/**
+ * Test-only alias for `resetProjectContextCache`. Kept for readability
+ * at test-call-sites — `__...ForTests` makes the test intent obvious.
+ * Production code MUST use the unprefixed name above.
+ */
+export function __resetProjectContextCacheForTests() {
+    resetProjectContextCache();
+}
+/**
+ * Returns the rendered <project_context> block for splicing into the
+ * user message, or '' when the flag is off / no context was detectable.
+ *
+ * Never throws — getProjectContext + renderProjectContext are both
+ * best-effort. Any IO error inside the project-context module returns
+ * the empty string, which makes the call site safely composable
+ * (`message = block + message`).
+ */
+export async function maybeBuildProjectContext(options) {
+    if (!isFlagOn())
+        return '';
+    // Treat empty-string cwd the same as a missing one. Node fs would
+    // resolve '' to process.cwd(), which would silently walk wherever
+    // the CLI was launched from — surprising and not what we want when
+    // the caller failed to populate the field.
+    if (!options.cwd)
+        return '';
+    if (cachedBlock !== null)
+        return cachedBlock;
+    try {
+        const ctx = await getProjectContext(options.cwd, {
+            sapConnection: options.sapConnection ?? null,
+        });
+        cachedBlock = ctx ? renderProjectContext(ctx) : '';
+    }
+    catch (err) {
+        // getProjectContext is documented as never-throws; reaching this
+        // catch means the contract was violated (regression in 1F or one
+        // of the extractors). Emit a one-shot stderr warning so a
+        // dogfooder sees a real signal — without it, "the model isn't
+        // using project_context" debugging starts with five wrong
+        // hypotheses. Subsequent calls in the same process stay silent.
+        if (!warnedOnce) {
+            warnedOnce = true;
+            const msg = err instanceof Error ? err.message : String(err);
+            try {
+                process.stderr.write(`[project-context] disabled for this session: ${msg}\n`);
+            }
+            catch {
+                // stderr write itself failed (closed pipe, etc.) — nothing more we can do.
+            }
+        }
+        cachedBlock = '';
+    }
+    return cachedBlock;
+}
+/**
+ * Pure check on the env-var. Exported for tests + for the loop call
+ * site to short-circuit before calling buildSystemPrompt-style helpers.
+ */
+export function isFlagOn() {
+    return process.env[PROJECT_CONTEXT_ENV_FLAG] === 'on';
+}

package/dist/agent/providers/ai-hub-provider.js

@@ -0,0 +1,58 @@
+import Anthropic from '@anthropic-ai/sdk';
+import keytar from 'keytar';
+import { createManifestSkillSource } from '../../skills/source-manifest.js';
+import { DEFAULT_MANIFEST_URL } from '../../skills/manifest-client.js';
+const KEYCHAIN_SERVICE = 'cspeach.ai-hub';
+const KEYCHAIN_ACCOUNT = 'token';
+export function createAiHubProvider(cfg) {
+    if (!cfg.llm.ai_hub_base_url) {
+        throw new Error('ai-hub mode requires llm.ai_hub_base_url — run: cspeach config set llm.ai_hub_base_url <url>');
+    }
+    const baseURL = cfg.llm.ai_hub_base_url;
+    const modelAlias = cfg.llm.ai_hub_model_alias ?? 'anthropic--claude-opus-4-6';
+    const skillSource = createManifestSkillSource(DEFAULT_MANIFEST_URL);
+    return {
+        name: 'sap-ai-hub',
+        mode: 'ai-hub',
+        skillSource,
+        async createStream(params, options = {}) {
+            const token = await getToken();
+            const sdk = new Anthropic({
+                apiKey: token,
+                baseURL,
+                defaultHeaders: { ...options.headers },
+            });
+            // v0.6 — pass AbortSignal so hard-interrupt tears down the stream.
+            return sdk.messages.stream({ ...params, model: modelAlias }, options.signal ? { signal: options.signal } : undefined);
+        },
+        async healthCheck() {
+            const token = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+            if (!token)
+                return { ok: false, message: 'AI Hub token not in keychain', hint: 'Run: cspeach config set llm.ai_hub_token <token>' };
+            try {
+                const sdk = new Anthropic({ apiKey: token, baseURL });
+                await sdk.messages.create({
+                    model: modelAlias,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                });
+            }
+            catch (e) {
+                return { ok: false, message: `AI Hub unreachable or auth failed: ${e.message}`, hint: 'Check the AI Core proxy URL and your token' };
+            }
+            try {
+                await skillSource.listAvailableSkills();
+            }
+            catch (e) {
+                return { ok: false, message: `AI Hub reachable, but manifest fetch/verify failed: ${e.message}`, hint: 'Check network access to manifest.cspeach.dev' };
+            }
+            return { ok: true, message: `AI Hub reachable (${baseURL}, model=${modelAlias}) + manifest verified` };
+        },
+    };
+}
+async function getToken() {
+    const t = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+    if (!t)
+        throw new Error('AI Hub token not configured');
+    return t;
+}

package/dist/agent/providers/byok-provider.js

@@ -0,0 +1,53 @@
+import Anthropic from '@anthropic-ai/sdk';
+import keytar from 'keytar';
+import { createManifestSkillSource } from '../../skills/source-manifest.js';
+import { DEFAULT_MANIFEST_URL } from '../../skills/manifest-client.js';
+const KEYCHAIN_SERVICE = 'cspeach.anthropic';
+const KEYCHAIN_ACCOUNT = 'api-key';
+// Cheapest Anthropic model available at doctor-probe time.
+const HEALTH_PROBE_MODEL = 'claude-haiku-4-6-latest';
+export function createByokProvider(_cfg) {
+    const skillSource = createManifestSkillSource(DEFAULT_MANIFEST_URL);
+    return {
+        name: 'anthropic-byok',
+        mode: 'byok',
+        skillSource,
+        async createStream(params, options = {}) {
+            const key = await getKey();
+            const sdk = new Anthropic({ apiKey: key, defaultHeaders: { ...options.headers } });
+            // v0.6 — pass AbortSignal so the agent loop's per-turn AbortController
+            // can tear down the stream on Esc / SIGINT-during-turn. The Anthropic
+            // SDK's `signal` option propagates to the underlying fetch.
+            return sdk.messages.stream(params, options.signal ? { signal: options.signal } : undefined);
+        },
+        async healthCheck() {
+            const key = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+            if (!key)
+                return { ok: false, message: 'Anthropic API key not in keychain', hint: 'Run: cspeach config set llm.byok_key <your-anthropic-key>' };
+            try {
+                const sdk = new Anthropic({ apiKey: key });
+                await sdk.messages.create({
+                    model: HEALTH_PROBE_MODEL,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                });
+            }
+            catch (e) {
+                return { ok: false, message: `BYOK auth failed: ${e.message}`, hint: 'Check your Anthropic key is current and has credit' };
+            }
+            try {
+                await skillSource.listAvailableSkills();
+            }
+            catch (e) {
+                return { ok: false, message: `BYOK key valid, but manifest fetch/verify failed: ${e.message}`, hint: 'Check network access to manifest.cspeach.dev; run `cspeach doctor --verbose` for the signature chain' };
+            }
+            return { ok: true, message: 'BYOK Anthropic key valid + manifest signature verified' };
+        },
+    };
+}
+async function getKey() {
+    const key = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+    if (!key)
+        throw new Error('BYOK Anthropic API key not configured — run: cspeach config set llm.byok_key <key>');
+    return key;
+}

package/dist/agent/providers/factory.js

@@ -0,0 +1,13 @@
+import { createManagedProvider } from '../anthropic-provider.js';
+import { createByokProvider } from './byok-provider.js';
+import { createAiHubProvider } from './ai-hub-provider.js';
+import { createLocalProvider } from './local-provider.js';
+export function createProviderForMode(cfg, getBearer) {
+    switch (cfg.llm.mode) {
+        case 'managed': return createManagedProvider(cfg, getBearer);
+        case 'byok': return createByokProvider(cfg);
+        case 'ai-hub': return createAiHubProvider(cfg);
+        case 'local': return createLocalProvider(cfg);
+        default: throw new Error(`unknown llm.mode: ${cfg.llm.mode}`);
+    }
+}

package/dist/agent/providers/local-provider.js

@@ -0,0 +1,125 @@
+import OpenAI from 'openai';
+import crypto from 'node:crypto';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { createBundledSkillSource } from '../../skills/source-bundled.js';
+import { BUNDLED_SKILLS } from '../../skills/bundled-skills.js';
+export function createLocalProvider(cfg) {
+    if (!cfg.llm.local_base_url) {
+        throw new Error('local mode requires llm.local_base_url — run: cspeach config set llm.local_base_url http://localhost:11434/v1');
+    }
+    const baseURL = cfg.llm.local_base_url;
+    const model = cfg.llm.local_model ?? 'llama3.1:70b';
+    const skillSource = createBundledSkillSource();
+    return {
+        name: 'local-openai-compat',
+        mode: 'local',
+        skillSource,
+        async createStream(params, options = {}) {
+            if (params.tools && params.tools.length > 0) {
+                throw new Error('Tool calling not supported in local mode (Plan A). Switch to managed/byok/ai-hub, or wait for the local-mode tool-calling follow-up PR.');
+            }
+            const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
+            const openAiParams = anthropicParamsToOpenAI(params, model);
+            // stream: true widens via object spread; the literal-true overload cannot be
+            // selected by structural inference, so cast to the streaming return shape.
+            // v0.6 — pass AbortSignal through OpenAI SDK request options.
+            const resp = (await sdk.chat.completions.create({ ...openAiParams, stream: true }, options.signal ? { signal: options.signal } : undefined));
+            return adaptOpenAiStreamToAnthropic(resp, model);
+        },
+        async healthCheck() {
+            try {
+                const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
+                await sdk.chat.completions.create({
+                    model,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                });
+            }
+            catch (e) {
+                return { ok: false, message: `Local endpoint unreachable: ${e.message}`, hint: `Is Ollama/vLLM running at ${baseURL}? Is ${model} loaded?` };
+            }
+            const bundled = Object.entries(BUNDLED_SKILLS);
+            if (bundled.length === 0) {
+                return { ok: false, message: 'No skills bundled in this CLI build', hint: 'This CLI was built without running `npm run prebuild`. Rebuild from source or install the published CLI.' };
+            }
+            const mismatches = [];
+            for (const [name, body] of bundled) {
+                const actual = bytesToHex(sha256(new TextEncoder().encode(body.body)));
+                if (actual !== body.sha256)
+                    mismatches.push(`${name} (manifest=${body.sha256}, actual=${actual})`);
+            }
+            if (mismatches.length > 0) {
+                return {
+                    ok: false,
+                    message: `bundled skill(s) sha256 mismatch: ${mismatches.join('; ')}`,
+                    hint: 'CLI binary may have been tampered with; reinstall from a trusted source.',
+                };
+            }
+            return { ok: true, message: `Local model ${model} at ${baseURL} responding; ${bundled.length} skills bundled (sha256 verified)` };
+        },
+    };
+}
+function anthropicParamsToOpenAI(p, model) {
+    const messages = [];
+    if (p.system) {
+        const sys = typeof p.system === 'string'
+            ? p.system
+            : p.system.map(s => s.text).join('\n');
+        messages.push({ role: 'system', content: sys });
+    }
+    for (const m of p.messages) {
+        const content = typeof m.content === 'string'
+            ? m.content
+            : Array.isArray(m.content)
+                ? m.content.filter(b => b.type === 'text').map(b => b.text).join('\n')
+                : String(m.content);
+        messages.push({ role: m.role, content });
+    }
+    return {
+        model,
+        max_tokens: p.max_tokens,
+        messages,
+    };
+}
+export async function* adaptOpenAiStreamToAnthropic(resp, model) {
+    const messageId = 'msg_' + crypto.randomUUID();
+    let outputTokens = 0;
+    let inputTokens = 0;
+    let stopReason = null;
+    let sentMessageStart = false;
+    let sentBlockStart = false;
+    for await (const chunk of resp) {
+        if (!sentMessageStart) {
+            sentMessageStart = true;
+            yield {
+                type: 'message_start',
+                message: { id: messageId, type: 'message', role: 'assistant', model, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } },
+            };
+            yield { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } };
+            sentBlockStart = true;
+        }
+        const choice = chunk.choices?.[0];
+        const deltaText = choice?.delta?.content;
+        if (typeof deltaText === 'string' && deltaText.length > 0) {
+            yield { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: deltaText } };
+        }
+        if (choice?.finish_reason) {
+            stopReason = choice.finish_reason === 'stop' ? 'end_turn'
+                : choice.finish_reason === 'length' ? 'max_tokens'
+                    : choice.finish_reason;
+        }
+        if (chunk.usage) {
+            outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+            inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+        }
+    }
+    if (sentBlockStart)
+        yield { type: 'content_block_stop', index: 0 };
+    yield {
+        type: 'message_delta',
+        delta: { stop_reason: stopReason ?? 'end_turn', stop_sequence: null },
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+    };
+    yield { type: 'message_stop' };
+}

package/dist/agent/repair-partial.js

@@ -0,0 +1,31 @@
+/**
+ * Repair partial assistant content blocks before persisting them to a session.
+ *
+ * When a provider stream is interrupted mid-flight (HTTP socket dropped,
+ * AbortController fired, network blip), the agent loop's accumulated
+ * `currentAssistantContent` may include `tool_use` blocks whose `input` JSON
+ * never finished streaming — typically the SDK has buffered the bytes into
+ * `partial_json` but `JSON.parse` was never called, so `input` is undefined.
+ *
+ * Persisting an assistant message that contains an incomplete tool_use block
+ * causes the next API call to reject the message with:
+ *   400 each `tool_use` block must contain `input` (or similar)
+ *
+ * Drop incomplete tool_use blocks. The model will re-emit them on the next
+ * round (the prior tool round's results are already on session.messages,
+ * giving the model the same context). Text and thinking blocks are kept
+ * even if truncated — partial prose is still useful for the user to read,
+ * and a short paragraph fragment is a valid assistant message.
+ */
+export function repairPartialBlocks(blocks) {
+    return blocks.filter((b) => {
+        if (b == null || typeof b !== 'object')
+            return false;
+        if (b.type === 'tool_use') {
+            // Complete only when input was successfully parsed (object, not undefined).
+            return b.input !== undefined;
+        }
+        // text, thinking, redacted_thinking, etc. — keep as-is.
+        return true;
+    });
+}

package/dist/agent/retry-key.js

@@ -0,0 +1,58 @@
+/**
+ * Retry-cap keying — produce a stable, distinguishing key per (tool, args)
+ * pair so consecutive failures of the SAME logical call accumulate, while
+ * independent calls (different args) are treated as independent attempts.
+ *
+ * Background
+ * ----------
+ * The agent loop caps consecutive failures per logical target to break out
+ * of approval-thrash / hard-loop scenarios where the model keeps re-trying
+ * the same broken call. The original keying used `${toolName}:${name}:${type}`
+ * which works for object-mutating tools (sap_set_source, sap_activate, etc.)
+ * — but for tools whose input doesn't carry name/type (sap_sql_query takes
+ * a `query`; sap_search_object takes a `query`; sap_short_dump takes a
+ * dump id) every call collapsed to `${toolName}::` and three independent
+ * probes were treated as three retries.
+ *
+ * Probe-heavy skills like /abap-cca DISCOVER (which intentionally probes
+ * 4 UPL table variants and skips missing ones) tripped the cap in normal
+ * operation.
+ *
+ * Fix
+ * ---
+ * - Prefer object identity when present (`name` / `type`, with
+ *   `object_name` / `object_type` as alternates) — preserves original
+ *   semantics for tools that target a named object.
+ * - Otherwise, key on a short stable hash of the full input JSON. Different
+ *   queries get different hashes; different keys; independent retry tallies.
+ *   Same query failing repeatedly still accumulates onto the same hash key.
+ *
+ * Hash: cheap djb2-style fold. We don't need crypto — only intra-turn
+ * uniqueness across a small handful of failed calls.
+ */
+export function objectKeyFromInput(toolName, input) {
+    const safe = input ?? {};
+    const name = pickString(safe, 'name') ?? pickString(safe, 'object_name') ?? '';
+    const type = pickString(safe, 'type') ?? pickString(safe, 'object_type') ?? '';
+    if (name.length > 0 || type.length > 0) {
+        return `${toolName}:${name}:${type}`;
+    }
+    // Fallback: distinguishing hash of all args. JSON.stringify with sorted
+    // keys would be more deterministic across object construction orders, but
+    // within a single turn the model emits args via a stable schema so plain
+    // stringify is enough.
+    const argsJson = JSON.stringify(safe);
+    return `${toolName}:#${cheapHash(argsJson)}`;
+}
+function pickString(input, key) {
+    const v = input[key];
+    return typeof v === 'string' && v.length > 0 ? v : null;
+}
+function cheapHash(s) {
+    // djb2 — small, deterministic, no deps. Returned as 8-char hex.
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) {
+        h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+    }
+    return (h >>> 0).toString(16).padStart(8, '0');
+}

package/dist/agent/retry.js

@@ -0,0 +1,17 @@
+export async function retryWithBackoff(fn, maxAttempts = 3, initialDelayMs = 2000) {
+    let delay = initialDelayMs;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const status = err?.status ?? err?.response?.status;
+            const retryable = status === 503 || status === 529;
+            if (!retryable || attempt === maxAttempts)
+                throw err;
+            await new Promise((r) => setTimeout(r, delay));
+            delay *= 4; // 2s → 8s → 32s
+        }
+    }
+    throw new Error('retry exhausted');
+}

package/dist/agent/sap-connection-adapter.js

@@ -0,0 +1,82 @@
+/**
+ * Phase 2.1 of Track B — SapConnectionContext adapter.
+ *
+ * Bridges CSPeach's existing per-session SAP state (alias, getSapSystemInfo
+ * cache, current pinned transport) into the SapConnectionContext shape
+ * the project-context renderer expects. This is what makes the
+ * `<sap_connection>` block in the rendered project_context actually
+ * populated for live-SAP sessions — Phase 2 left it as null.
+ *
+ * Best-effort: every input is optional. Missing values become null in
+ * the output rather than blocking the call. The renderer in
+ * project-context/render.ts handles nulls gracefully (omits empty
+ * sub-elements).
+ *
+ * Out of scope (later refinements):
+ *
+ *  - `recentObjects` is currently '[]'. Capturing the last-N
+ *    sap_get_source / sap_set_source / sap_atc_run targets would
+ *    require touching the tool dispatch layer to record per-call
+ *    metadata. Phase 2.2+ work.
+ *
+ *  - `host` (the system endpoint) is null. AdtClient knows it but
+ *    exposing it through the public types touches the sap-client API
+ *    surface. Adapter leaves it null until that's deliberate.
+ */
+/**
+ * Assemble a SapConnectionContext from the alias, the cached
+ * SapSystemInfo (from getSapSystemInfo), and any per-session state
+ * the caller can supply. Pass an empty `state` object when nothing
+ * beyond the alias + system info is known.
+ */
+export function buildSapConnectionContext(alias, systemInfo, state = {}) {
+    return {
+        alias,
+        system: toSummary(systemInfo),
+        currentTransport: state.currentTransport ?? null,
+        activeScope: toActiveScope(state),
+        recentObjects: state.recentObjects ?? [],
+    };
+}
+/* ── Internals ─────────────────────────────────────────────────────── */
+function toSummary(info) {
+    if (!info) {
+        return {
+            sid: null,
+            release: null,
+            abapVersion: null,
+            platform: 'unknown',
+            host: null,
+        };
+    }
+    return {
+        // SapSystemInfo doesn't carry a SID today — populated when the
+        // future ENVIRONMENT-INFO query lands. Null is the honest default.
+        sid: null,
+        release: info.release || null,
+        abapVersion: info.abapVersion || null,
+        platform: toPlatform(info.deployment),
+        host: null,
+    };
+}
+function toPlatform(deployment) {
+    switch (deployment) {
+        case 'public-cloud':
+            return 'cloud';
+        case 'on-prem-or-private-cloud':
+            return 'on-premise';
+        case 'unknown':
+        default:
+            return 'unknown';
+    }
+}
+function toActiveScope(state) {
+    const hasPackage = typeof state.activePackage === 'string' && state.activePackage.length > 0;
+    const hasObject = state.activeObject != null;
+    if (!hasPackage && !hasObject)
+        return null;
+    return {
+        package: hasPackage ? state.activePackage : null,
+        object: hasObject ? state.activeObject : null,
+    };
+}