subconscious-cli 6.0.1 → 6.2.0

package/bin/runbook/opencode/provider.sh

@@ -1,93 +0,0 @@
-#!/usr/bin/env bash
-# Shared OpenCode provider metadata for subc launch and install paths.
-
-# OpenCode groups /models entries by provider.name. Keep this stable and human
-# readable.
-SUBC_OPENCODE_PROVIDER_ID="subconscious"
-SUBC_OPENCODE_PROVIDER_NAME="Subconscious Gateway"
-
-subc_opencode_model_display_name() {
-  local slug="${1:-}"
-  slug="${slug#subconscious/}"
-  echo "$slug" | awk -F '[-_]' '
-    function format_token(token, lower) {
-      lower = tolower(token)
-      if (lower ~ /^(gpt|oss|api|gguf|ggml|nomic|vl|it|mlx)$/) return toupper(token)
-      if (token ~ /^[0-9]+[bBkKmMgG]$/) return toupper(token)
-      if (token ~ /^[qQ][0-9]+$/) return toupper(token)
-      if (token ~ /^[0-9]+\.[0-9]+/) return token
-      if (token ~ /^[A-Za-z][0-9]+[A-Za-z]$/ || token ~ /^[0-9]+[A-Za-z]$/) return toupper(token)
-      return toupper(substr(token, 1, 1)) tolower(substr(token, 2))
-    }
-    {
-      out = ""
-      for (i = 1; i <= NF; i++) {
-        if ($i == "") continue
-        out = out (out == "" ? "" : " ") format_token($i)
-      }
-      print out
-    }
-  '
-}
-
-subc_opencode_build_whitelist_json() {
-  local model_id
-  WHITELIST_JSON=""
-  for model_id in "${SUPPORTED_MODELS[@]}"; do
-    if [[ -n "$WHITELIST_JSON" ]]; then
-      WHITELIST_JSON="${WHITELIST_JSON},\"${model_id}\""
-    else
-      WHITELIST_JSON="\"${model_id}\""
-    fi
-  done
-  WHITELIST_JSON="[${WHITELIST_JSON}]"
-}
-
-subc_opencode_build_models_json() {
-  local model_id display_name vision_fields model_json
-  MODELS_JSON=""
-  for model_id in "${SUPPORTED_MODELS[@]}"; do
-    display_name="$(subc_opencode_model_display_name "$model_id")"
-    vision_fields=""
-    if subc_model_supports_vision "$model_id"; then
-      vision_fields=',"attachment":true,"modalities":{"input":["text","image"],"output":["text"]}'
-    fi
-    model_json="\"${model_id}\":{\"name\":\"${display_name}\",\"tools\":true,\"limit\":{\"context\":${CONTEXT_LIMIT},\"output\":${OUTPUT_LIMIT}}${vision_fields}}"
-    if [[ -n "$MODELS_JSON" ]]; then
-      MODELS_JSON="${MODELS_JSON},${model_json}"
-    else
-      MODELS_JSON="$model_json"
-    fi
-  done
-  subc_opencode_build_whitelist_json
-}
-
-subc_opencode_build_config_json() {
-  local base_url="${1:?base url required}"
-  local model="${2:?model required}"
-  cat <<EOF
-{"\$schema":"https://opencode.ai/config.json","disabled_providers":["subconscious-cli"],"provider":{"${SUBC_OPENCODE_PROVIDER_ID}":{"npm":"@ai-sdk/openai-compatible","name":"${SUBC_OPENCODE_PROVIDER_NAME}","whitelist":${WHITELIST_JSON},"options":{"baseURL":"${base_url}","apiKey":"{env:SUBCONSCIOUS_API_KEY}","headers":{"x-subconscious-client":"opencode"},"modelsDiscovery":{"enabled":false}},"models":{${MODELS_JSON}}}},"model":"${SUBC_OPENCODE_PROVIDER_ID}/${model}"}
-EOF
-}
-
-subc_opencode_build_provider_json() {
-  local base_url="${1:?base url required}"
-  cat <<EOF
-{
-  "npm": "@ai-sdk/openai-compatible",
-  "name": "${SUBC_OPENCODE_PROVIDER_NAME}",
-  "whitelist": ${WHITELIST_JSON},
-  "options": {
-    "baseURL": "${base_url}",
-    "apiKey": "{env:SUBCONSCIOUS_API_KEY}",
-    "headers": {
-      "x-subconscious-client": "opencode"
-    },
-    "modelsDiscovery": {
-      "enabled": false
-    }
-  },
-  "models": {${MODELS_JSON}}
-}
-EOF
-}

package/bin/runbook/opencode/run.sh

@@ -1,99 +0,0 @@
-#!/usr/bin/env bash
-# Point OpenCode at the Subconscious gateway — ephemerally.
-#
-# Exports SUBCONSCIOUS_API_KEY and OPENCODE_CONFIG_CONTENT as env vars so
-# nothing is written to ~/.opencode/opencode.json. OpenCode reads the
-# config from the OPENCODE_CONFIG_CONTENT env var at startup.
-#
-# Usage:
-#   ./run.sh                         # uses GATEWAY_URL/API_KEY from ../.env
-#   ./run.sh -- auth                 # pass args through to opencode
-#
-# Config: copy ../env.example to ../.env and edit. .env is gitignored.
-# Profile env is injected by subc. A sibling .env is only used when SUBC_ENV_FILE is unset.
-#
-# Or source it to just export the env:
-#   source run.sh
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../model-capabilities.generated.sh"
-source "${SCRIPT_DIR}/provider.sh"
-
-# Load shared env from SUBC_ENV_FILE, or a sibling .env / env.example.
-SHARED_ENV="${SUBC_ENV_FILE:-${SCRIPT_DIR}/../.env}"
-[[ -f "$SHARED_ENV" ]] || SHARED_ENV="${SCRIPT_DIR}/../env.example"
-if [[ -f "$SHARED_ENV" ]]; then set -a; source "$SHARED_ENV"; set +a; fi
-
-GATEWAY_URL="${GATEWAY_URL:-}"
-API_KEY="${OPENCODE_API_KEY:-${API_KEY:-}}"
-MODEL="${MODEL:-subconscious/glm-5.3-marathon}"
-CONTEXT_LIMIT="${OPENCODE_CONTEXT_LIMIT:-5000000}"
-OUTPUT_LIMIT="${OPENCODE_OUTPUT_LIMIT:-65536}"
-
-DEFAULT_SUBCONSCIOUS_MODELS="subconscious/glm-5.3-marathon
-subconscious/glm-5.2
-subconscious/tim-qwen3.6-27b
-subconscious/deepseek-v4-flash-marathon
-subconscious/deepseek-v4.1-flash-marathon"
-SUPPORTED_MODELS=()
-
-add_supported_model() {
-  local model_id="$1" existing
-  [[ -n "$model_id" ]] || return 0
-  if [[ ! "$model_id" =~ ^[-A-Za-z0-9._:/+]+$ ]]; then
-    echo "error: invalid model id: $model_id" >&2
-    exit 1
-  fi
-  if [[ "${#SUPPORTED_MODELS[@]}" -gt 0 ]]; then
-    for existing in "${SUPPORTED_MODELS[@]}"; do
-      [[ "$existing" == "$model_id" ]] && return 0
-    done
-  fi
-  SUPPORTED_MODELS+=("$model_id")
-}
-
-add_supported_model "$MODEL"
-while IFS= read -r model_id; do
-  add_supported_model "$model_id"
-done <<< "${SUBCONSCIOUS_MODELS:-$DEFAULT_SUBCONSCIOUS_MODELS}"
-
-subc_opencode_build_models_json
-
-if [[ -z "$GATEWAY_URL" || -z "$API_KEY" ]]; then
-  echo "error: GATEWAY_URL and API_KEY must be set in ../.env" >&2
-  exit 1
-fi
-
-# Parse args (only when executed, not sourced)
-PASSTHRU=()
-if [[ "${BASH_SOURCE[0]:-$0}" == "${0}" ]]; then
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --)
-        shift
-        PASSTHRU+=("$@")
-        break
-        ;;
-      *)
-        PASSTHRU+=("$1")
-        shift
-        ;;
-    esac
-  done
-fi
-
-BASE_URL="${GATEWAY_URL%/}/v1"
-
-export SUBCONSCIOUS_API_KEY="$API_KEY"
-# Compaction reporting needs the plugin on disk; this launch path writes nothing.
-export SUBCONSCIOUS_GATEWAY_URL="${GATEWAY_URL%/}"
-export OPENCODE_CONFIG_CONTENT="$(subc_opencode_build_config_json "$BASE_URL" "$MODEL")"
-
-# If sourced, just export env and return.
-if [[ "${BASH_SOURCE[0]:-$0}" != "${0}" ]]; then
-  return 0 2>/dev/null || true
-fi
-
-exec opencode ${PASSTHRU[@]+"${PASSTHRU[@]}"}

package/bin/runbook/opencode/subconscious-compaction.ts

@@ -1,100 +0,0 @@
-/**
- * Report OpenCode compactions to the Subconscious API Gateway.
- *
- * Why this exists: OpenCode summarizes by issuing an ordinary completion through the
- * configured provider, which is the gateway, carrying the same session headers as every
- * other turn. Without a signal the gateway would count that summarization as the largest
- * main-thread turn of the conversation, inflating peak context and the traditional
- * comparison at exactly the turn where accuracy matters most.
- *
- * Two callbacks bracket it:
- *   experimental.session.compacting -> phase "start" (awaited, so it is ordered before
- *                                     the summarization request reaches the gateway)
- *   session.compacted event         -> phase "end"
- *
- * Requests between them are the compaction. `sessionID` is the same value OpenCode sends
- * as x-session-affinity / x-session-id, which is already the gateway's grouping key, so
- * no fingerprinting is involved.
- *
- * Fail open: a gateway that is down or slow must never disturb a coding session.
- *
- * Install: copy to ~/.config/opencode/plugins/ (global) or .opencode/plugins/ (project).
- * `opencode/install.sh` does this for you.
- */
-
-import type { Plugin } from '@opencode-ai/plugin';
-
-const TIMEOUT_MS = 2000;
-
-function gatewayUrl(): string | undefined {
-  const raw = process.env.SUBCONSCIOUS_GATEWAY_URL ?? process.env.GATEWAY_URL;
-  return raw ? raw.replace(/\/+$/, '') : undefined;
-}
-
-function apiKey(): string | undefined {
-  return process.env.SUBCONSCIOUS_API_KEY ?? process.env.API_KEY;
-}
-
-async function report(
-  sessionID: string,
-  phase: 'start' | 'end',
-  hookEventName: string,
-): Promise<void> {
-  const url = gatewayUrl();
-  const key = apiKey();
-  if (!url || !key || !sessionID) return;
-
-  // Idempotency key for this one event. It must be unique per compaction but stable for
-  // a redelivery of this same POST, so it is derived from the wall clock rather than any
-  // in-process counter: a counter resets when OpenCode restarts, and a resumed session
-  // compacting again would then reuse a key the gateway has already seen and silently
-  // drop the signal. Computed once here, before the request, so a transport-level retry
-  // carries the identical body.
-  const dedupeKey = `${sessionID}:${phase}:${Date.now()}`;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
-  try {
-    await fetch(`${url}/v1/agent-hooks`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        authorization: `Bearer ${key}`,
-        'x-subconscious-client': 'opencode',
-      },
-      body: JSON.stringify({
-        event: 'conversation_compaction',
-        conversation_id: sessionID,
-        phase,
-        hook_event_name: hookEventName,
-        dedupe_key: dedupeKey,
-      }),
-      signal: controller.signal,
-    });
-  } catch {
-    // Fail open on timeout, offline gateway, or auth failure.
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export const SubconsciousCompaction: Plugin = async () => {
-  return {
-    'experimental.session.compacting': async (input) => {
-      // Deliberately does not touch `output`: mutating `context` would change the
-      // customer's compaction prompt, and setting `prompt` would replace it entirely.
-      await report(input.sessionID, 'start', 'session.compacting');
-    },
-    event: async ({ event }) => {
-      if (event.type === 'session.compacted') {
-        const sessionID = (event as { properties?: { sessionID?: string } })
-          .properties?.sessionID;
-        if (sessionID) {
-          // No shared id with the matching `start` is needed: the gateway pairs a start
-          // with the next end by server-stamped time, not by key.
-          await report(sessionID, 'end', 'session.compacted');
-        }
-      }
-    },
-  };
-};

package/bin/runbook/subconscious-code/install.sh

@@ -1,154 +0,0 @@
-#!/usr/bin/env bash
-# Install a precompiled Marathon release for the current platform.
-
-set -euo pipefail
-
-REPOSITORY="subconscious-systems/subconscious-code"
-REPOSITORY_URL="https://github.com/${REPOSITORY}"
-INSTALL_DIR="${SC_INSTALL_DIR:-${HOME}/.local/bin}"
-
-usage() {
-  cat <<'EOF'
-Usage: subc marathon install
-
-Install the latest Marathon release. Linux downloads and verifies the
-published static binary. macOS downloads and verifies the matching native binary.
-EOF
-}
-
-case "${1:-install}" in
-  install) ;;
-  help|-h|--help)
-    usage
-    exit 0
-    ;;
-  *)
-    echo "error: unsupported Marathon setup action: $1" >&2
-    usage >&2
-    exit 2
-    ;;
-esac
-
-release_tag() {
-  if [[ -n "${SC_CODE_VERSION:-}" ]]; then
-    printf '%s\n' "${SC_CODE_VERSION#v}"
-    return
-  fi
-  if command -v gh >/dev/null 2>&1; then
-    local tag
-    tag="$(gh release view --repo "$REPOSITORY" --json tagName --jq '.tagName' 2>/dev/null || true)"
-    if [[ -n "$tag" ]]; then
-      printf '%s\n' "${tag#v}"
-      return
-    fi
-  fi
-  if command -v curl >/dev/null 2>&1; then
-    local tag
-    tag="$(curl -fsSL "https://api.github.com/repos/${REPOSITORY}/releases/latest" 2>/dev/null \
-      | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
-      | head -n 1 || true)"
-    if [[ -n "$tag" ]]; then
-      printf '%s\n' "${tag#v}"
-      return
-    fi
-  fi
-  return 1
-}
-
-platform="$(uname -s)"
-architecture="$(uname -m)"
-version="$(release_tag || true)"
-
-if [[ -z "$version" ]]; then
-  echo "error: no published Marathon release is available yet" >&2
-  echo "The release may still be building. Retry subc marathon install after it finishes." >&2
-  exit 1
-fi
-
-case "${platform}:${architecture}" in
-  Darwin:arm64) target="aarch64-apple-darwin" ;;
-  Darwin:x86_64) target="x86_64-apple-darwin" ;;
-  Linux:aarch64|Linux:arm64) target="aarch64-unknown-linux-musl" ;;
-  Linux:x86_64|Linux:amd64) target="x86_64-unknown-linux-musl" ;;
-  *)
-    echo "error: unsupported platform or architecture: ${platform} ${architecture}" >&2
-    exit 1
-    ;;
-esac
-
-executable="marathon"
-asset="${executable}-${target}.tar.gz"
-checksum="${asset}.sha256"
-work_dir="$(mktemp -d "${TMPDIR:-/tmp}/subc-marathon-install.XXXXXX")"
-staging=''
-cleanup() {
-  rm -f "$work_dir/$asset" "$work_dir/$checksum" "$work_dir/sc" "$work_dir/marathon"
-  if [[ -n "$staging" ]]; then rm -f "$staging"; fi
-  rmdir "$work_dir" 2>/dev/null || true
-}
-trap cleanup EXIT HUP INT TERM
-
-echo "Downloading Marathon v${version} for ${target}..."
-if command -v gh >/dev/null 2>&1 \
-  && assets="$(gh release view "v${version}" --repo "$REPOSITORY" --json assets --jq '.assets[].name' 2>/dev/null)"; then
-  if ! printf '%s\n' "$assets" | grep -Fxq "$asset"; then
-    # Pinned legacy releases are still installed as marathon, never as sc.
-    executable="sc"
-    asset="${executable}-${target}.tar.gz"
-    checksum="${asset}.sha256"
-  fi
-  if ! printf '%s\n' "$assets" | grep -Fxq "$asset" \
-    || ! printf '%s\n' "$assets" | grep -Fxq "$checksum"; then
-    echo "error: release is missing $asset or $checksum" >&2
-    exit 1
-  fi
-  gh release download "v${version}" --repo "$REPOSITORY" \
-    --pattern "$asset" --pattern "$checksum" --dir "$work_dir"
-else
-  command -v curl >/dev/null 2>&1 || {
-    echo "error: curl is required to download Marathon" >&2
-    exit 1
-  }
-  release_url="${REPOSITORY_URL}/releases/download/v${version}"
-  status="$(curl -sSL -w '%{http_code}' "${release_url}/${asset}" -o "$work_dir/$asset")"
-  if [[ "$status" == 404 ]]; then
-    rm -f "$work_dir/$asset"
-    executable="sc"
-    asset="${executable}-${target}.tar.gz"
-    checksum="${asset}.sha256"
-    curl -fL "${release_url}/${asset}" -o "$work_dir/$asset"
-  elif [[ "$status" != 200 ]]; then
-    echo "error: Marathon download failed (HTTP $status)" >&2
-    exit 1
-  fi
-  curl -fL "${release_url}/${checksum}" -o "$work_dir/$checksum"
-fi
-
-if command -v sha256sum >/dev/null 2>&1; then
-  (cd "$work_dir" && sha256sum --check "$checksum")
-elif command -v shasum >/dev/null 2>&1; then
-  expected="$(awk '{print $1}' "$work_dir/$checksum")"
-  actual="$(shasum -a 256 "$work_dir/$asset" | awk '{print $1}')"
-  [[ "$actual" == "$expected" ]] || {
-    echo "error: Marathon checksum verification failed" >&2
-    exit 1
-  }
-else
-  echo "error: sha256sum or shasum is required to verify the download" >&2
-  exit 1
-fi
-
-tar -xzf "$work_dir/$asset" -C "$work_dir" "$executable"
-if [[ ! -f "$work_dir/$executable" || -L "$work_dir/$executable" ]]; then
-  echo "error: release has no regular root $executable executable" >&2
-  exit 1
-fi
-mkdir -p "$INSTALL_DIR"
-if [[ -d "$INSTALL_DIR/marathon" ]]; then
-  echo "error: $INSTALL_DIR/marathon is a directory; refusing to replace it" >&2
-  exit 1
-fi
-staging="$(mktemp "$INSTALL_DIR/.marathon.XXXXXX")"
-install -m 0755 "$work_dir/$executable" "$staging"
-mv -f "$staging" "$INSTALL_DIR/marathon"
-echo "Installed Marathon v${version} to $INSTALL_DIR/marathon"

package/bin/runbook/subconscious-code/run.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# Launch Marathon without changing ~/.sc or project settings.
-
-set -euo pipefail
-
-GATEWAY_URL="${GATEWAY_URL:-}"
-API_KEY="${SC_API_KEY:-${API_KEY:-}}"
-MODEL="${MODEL:-subconscious/glm-5.3-marathon}"
-
-if [[ -z "$GATEWAY_URL" || -z "$API_KEY" ]]; then
-  echo "error: GATEWAY_URL and API_KEY are required to launch Marathon" >&2
-  exit 1
-fi
-
-export SC_API_KEY="$API_KEY"
-export SC_BASE_URL="${GATEWAY_URL%/}/v1"
-export SC_DLR_URL="${GATEWAY_URL%/}"
-export SC_DLR_ENABLED=true
-export SC_MODEL="$MODEL"
-
-exec marathon "$@"

package/bin/windows/claude.js

@@ -1,100 +0,0 @@
-// Windows-only equivalent of the existing Claude shell launch.
-import { readFileSync } from 'node:fs';
-import { resolvedModelSetting } from '../profiles.js';
-import { parseOptions, positiveInteger } from './common.js';
-
-const DEFAULTS = JSON.parse(
-  readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'),
-).defaults;
-function claudePickerSettings(models) {
-  return {
-    availableModels: models,
-    modelPicker: {
-      replaceBuiltInOptions: true,
-      options: models.map((model) => ({
-        model,
-        label: model,
-        description: `Subconscious model ${model}`,
-      })),
-    },
-  };
-}
-
-export function claudeNativeLaunch(argv, environment) {
-  const { options, rest: passthrough } = parseOptions(argv, {
-    '--gateway-url': 1,
-    '--api-key': 1,
-    '--model': 1,
-    '--compact-window': 1,
-    '--max-context-tokens': 1,
-  });
-  const gatewayUrl =
-    options['--gateway-url'] || environment.GATEWAY_URL?.trim() || '';
-  const apiKey =
-    options['--api-key'] ||
-    environment.CLAUDE_CODE_API_KEY?.trim() ||
-    environment.API_KEY?.trim() ||
-    '';
-  const model =
-    options['--model'] || environment.MODEL?.trim() || DEFAULTS.model;
-  const compactWindow =
-    options['--compact-window'] ||
-    environment.CLAUDE_CODE_AUTO_COMPACT_WINDOW?.trim() ||
-    environment.COMPACT_WINDOW?.trim() ||
-    '1000000';
-  const maxContextTokens =
-    options['--max-context-tokens'] ||
-    environment.CLAUDE_CODE_MAX_CONTEXT_TOKENS?.trim() ||
-    environment.MAX_CONTEXT_TOKENS?.trim() ||
-    '3000000';
-
-  if (!gatewayUrl || !apiKey) {
-    throw new Error(
-      'GATEWAY_URL and API_KEY are required to launch Claude Code',
-    );
-  }
-  positiveInteger(compactWindow, 'compact-window');
-  positiveInteger(maxContextTokens, 'max-context-tokens');
-
-  const effectiveGatewayUrl =
-    environment.CLAUDE_GATEWAY_URL?.trim() || gatewayUrl;
-  const subagentModel =
-    resolvedModelSetting(environment.CLAUDE_CODE_SUBAGENT_MODEL) || model;
-  const settings =
-    environment.SUBC_CLAUDE_SETTINGS?.trim() ||
-    JSON.stringify(claudePickerSettings([model], model));
-  const withoutTrailingSlash = effectiveGatewayUrl.replace(/\/+$/, '');
-  const env = {
-    ...environment,
-    ANTHROPIC_BASE_URL: effectiveGatewayUrl,
-    ANTHROPIC_AUTH_TOKEN: apiKey,
-    ANTHROPIC_MODEL: environment.ANTHROPIC_MODEL?.trim() || model,
-    ANTHROPIC_SMALL_FAST_MODEL:
-      environment.ANTHROPIC_SMALL_FAST_MODEL?.trim() || model,
-    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:
-      environment.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY?.trim() || '0',
-    CLAUDE_CODE_SUBAGENT_MODEL: subagentModel,
-    CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS:
-      environment.MAX_CONCURRENT_SUBAGENTS?.trim() || '4',
-    CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH:
-      environment.MAX_SUBAGENT_SPAWN_DEPTH?.trim() || '1',
-    CLAUDE_CODE_AUTO_COMPACT_WINDOW: compactWindow,
-    CLAUDE_CODE_MAX_CONTEXT_TOKENS: maxContextTokens,
-    CLAUDE_CODE_ENABLE_TELEMETRY:
-      environment.CLAUDE_CODE_ENABLE_TELEMETRY?.trim() || '1',
-    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:
-      environment.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC?.trim() || '1',
-    ENABLE_CLAUDEAI_MCP_SERVERS: 'false',
-    OTEL_LOGS_EXPORTER: environment.OTEL_LOGS_EXPORTER?.trim() || 'otlp',
-    OTEL_EXPORTER_OTLP_PROTOCOL:
-      environment.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() || 'http/json',
-    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${withoutTrailingSlash}/v1/logs`,
-    OTEL_EXPORTER_OTLP_HEADERS: `x-api-key=${apiKey}`,
-    OTEL_EXPORTER_OTLP_TIMEOUT:
-      environment.OTEL_EXPORTER_OTLP_TIMEOUT?.trim() || '2000',
-    OTEL_LOGS_EXPORT_INTERVAL:
-      environment.OTEL_LOGS_EXPORT_INTERVAL?.trim() || '2000',
-  };
-
-  return { args: ['--settings', settings, ...passthrough], env };
-}