@caspian2026/agent-sdk 0.0.8 → 0.0.11

package/dist/chunk-njrt3tac.js

@@ -1,640 +0,0 @@
-// @bun
-import {
-  getAnthropicApiKey,
-  getClaudeAIOAuthTokens,
-  getGlobalConfig,
-  hasProfileScope,
-  init_auth,
-  init_config,
-  saveApiKey,
-  saveGlobalConfig
-} from "./chunk-e7efcp3k.js";
-import {
-  init_lazySchema,
-  lazySchema
-} from "./chunk-64c1avct.js";
-import {
-  init_sleep,
-  sleep
-} from "./chunk-8g5pe1gr.js";
-import {
-  init_v4,
-  v4_default
-} from "./chunk-8g747a8x.js";
-import {
-  ALL_OAUTH_SCOPES,
-  CLAUDE_AI_INFERENCE_SCOPE,
-  CLAUDE_AI_OAUTH_SCOPES,
-  OAUTH_BETA_HEADER,
-  getOauthConfig,
-  init_oauth
-} from "./chunk-s3hsqf80.js";
-import {
-  init_analytics,
-  logEvent
-} from "./chunk-x8d2ehd7.js";
-import {
-  init_detectRepository,
-  parseGitHubRepository
-} from "./chunk-15m49c67.js";
-import {
-  init_log,
-  logError
-} from "./chunk-1nk93fqz.js";
-import {
-  errorMessage,
-  init_debug,
-  init_errors,
-  init_slowOperations,
-  jsonStringify,
-  logForDebugging,
-  toError
-} from "./chunk-phd1qfpc.js";
-import {
-  axios_default,
-  init_axios
-} from "./chunk-55raexh7.js";
-import {
-  __esm
-} from "./chunk-qp2qdcda.js";
-
-// src/services/oauth/getOauthProfile.ts
-async function getOauthProfileFromApiKey() {
-  const config = getGlobalConfig();
-  const accountUuid = config.oauthAccount?.accountUuid;
-  const apiKey = getAnthropicApiKey();
-  if (!accountUuid || !apiKey) {
-    return;
-  }
-  const endpoint = `${getOauthConfig().BASE_API_URL}/api/claude_cli_profile`;
-  try {
-    const response = await axios_default.get(endpoint, {
-      headers: {
-        "x-api-key": apiKey,
-        "anthropic-beta": OAUTH_BETA_HEADER
-      },
-      params: {
-        account_uuid: accountUuid
-      },
-      timeout: 1e4
-    });
-    return response.data;
-  } catch (error) {
-    logError(error);
-  }
-}
-async function getOauthProfileFromOauthToken(accessToken) {
-  const endpoint = `${getOauthConfig().BASE_API_URL}/api/oauth/profile`;
-  try {
-    const response = await axios_default.get(endpoint, {
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json"
-      },
-      timeout: 1e4
-    });
-    return response.data;
-  } catch (error) {
-    logError(error);
-  }
-}
-var init_getOauthProfile = __esm(() => {
-  init_axios();
-  init_oauth();
-  init_auth();
-  init_config();
-  init_log();
-});
-
-// src/services/oauth/client.ts
-function shouldUseClaudeAIAuth(scopes) {
-  return Boolean(scopes?.includes(CLAUDE_AI_INFERENCE_SCOPE));
-}
-function parseScopes(scopeString) {
-  return scopeString?.split(" ").filter(Boolean) ?? [];
-}
-function buildAuthUrl({
-  codeChallenge,
-  state,
-  port,
-  isManual,
-  loginWithClaudeAi,
-  inferenceOnly,
-  orgUUID,
-  loginHint,
-  loginMethod
-}) {
-  const authUrlBase = loginWithClaudeAi ? getOauthConfig().CLAUDE_AI_AUTHORIZE_URL : getOauthConfig().CONSOLE_AUTHORIZE_URL;
-  const authUrl = new URL(authUrlBase);
-  authUrl.searchParams.append("code", "true");
-  authUrl.searchParams.append("client_id", getOauthConfig().CLIENT_ID);
-  authUrl.searchParams.append("response_type", "code");
-  authUrl.searchParams.append("redirect_uri", isManual ? getOauthConfig().MANUAL_REDIRECT_URL : `http://localhost:${port}/callback`);
-  const scopesToUse = inferenceOnly ? [CLAUDE_AI_INFERENCE_SCOPE] : ALL_OAUTH_SCOPES;
-  authUrl.searchParams.append("scope", scopesToUse.join(" "));
-  authUrl.searchParams.append("code_challenge", codeChallenge);
-  authUrl.searchParams.append("code_challenge_method", "S256");
-  authUrl.searchParams.append("state", state);
-  if (orgUUID) {
-    authUrl.searchParams.append("orgUUID", orgUUID);
-  }
-  if (loginHint) {
-    authUrl.searchParams.append("login_hint", loginHint);
-  }
-  if (loginMethod) {
-    authUrl.searchParams.append("login_method", loginMethod);
-  }
-  return authUrl.toString();
-}
-async function exchangeCodeForTokens(authorizationCode, state, codeVerifier, port, useManualRedirect = false, expiresIn) {
-  const requestBody = {
-    grant_type: "authorization_code",
-    code: authorizationCode,
-    redirect_uri: useManualRedirect ? getOauthConfig().MANUAL_REDIRECT_URL : `http://localhost:${port}/callback`,
-    client_id: getOauthConfig().CLIENT_ID,
-    code_verifier: codeVerifier,
-    state
-  };
-  if (expiresIn !== undefined) {
-    requestBody.expires_in = expiresIn;
-  }
-  const response = await axios_default.post(getOauthConfig().TOKEN_URL, requestBody, {
-    headers: { "Content-Type": "application/json" },
-    timeout: 15000
-  });
-  if (response.status !== 200) {
-    throw new Error(response.status === 401 ? "Authentication failed: Invalid authorization code" : `Token exchange failed (${response.status}): ${response.statusText}`);
-  }
-  logEvent("tengu_oauth_token_exchange_success", {});
-  return response.data;
-}
-async function refreshOAuthToken(refreshToken, { scopes: requestedScopes } = {}) {
-  const requestBody = {
-    grant_type: "refresh_token",
-    refresh_token: refreshToken,
-    client_id: getOauthConfig().CLIENT_ID,
-    scope: ((requestedScopes?.length) ? requestedScopes : CLAUDE_AI_OAUTH_SCOPES).join(" ")
-  };
-  try {
-    const response = await axios_default.post(getOauthConfig().TOKEN_URL, requestBody, {
-      headers: { "Content-Type": "application/json" },
-      timeout: 15000
-    });
-    if (response.status !== 200) {
-      throw new Error(`Token refresh failed: ${response.statusText}`);
-    }
-    const data = response.data;
-    const {
-      access_token: accessToken,
-      refresh_token: newRefreshToken = refreshToken,
-      expires_in: expiresIn
-    } = data;
-    const expiresAt = Date.now() + expiresIn * 1000;
-    const scopes = parseScopes(data.scope);
-    logEvent("tengu_oauth_token_refresh_success", {});
-    const config = getGlobalConfig();
-    const existing = getClaudeAIOAuthTokens();
-    const haveProfileAlready = config.oauthAccount?.billingType !== undefined && config.oauthAccount?.accountCreatedAt !== undefined && config.oauthAccount?.subscriptionCreatedAt !== undefined && existing?.subscriptionType != null && existing?.rateLimitTier != null;
-    const profileInfo = haveProfileAlready ? null : await fetchProfileInfo(accessToken);
-    if (profileInfo && config.oauthAccount) {
-      const updates = {};
-      if (profileInfo.displayName !== undefined) {
-        updates.displayName = profileInfo.displayName;
-      }
-      if (typeof profileInfo.hasExtraUsageEnabled === "boolean") {
-        updates.hasExtraUsageEnabled = profileInfo.hasExtraUsageEnabled;
-      }
-      if (profileInfo.billingType !== null) {
-        updates.billingType = profileInfo.billingType;
-      }
-      if (profileInfo.accountCreatedAt !== undefined) {
-        updates.accountCreatedAt = profileInfo.accountCreatedAt;
-      }
-      if (profileInfo.subscriptionCreatedAt !== undefined) {
-        updates.subscriptionCreatedAt = profileInfo.subscriptionCreatedAt;
-      }
-      if (Object.keys(updates).length > 0) {
-        saveGlobalConfig((current) => ({
-          ...current,
-          oauthAccount: current.oauthAccount ? { ...current.oauthAccount, ...updates } : current.oauthAccount
-        }));
-      }
-    }
-    return {
-      accessToken,
-      refreshToken: newRefreshToken,
-      expiresAt,
-      scopes,
-      subscriptionType: profileInfo?.subscriptionType ?? existing?.subscriptionType ?? null,
-      rateLimitTier: profileInfo?.rateLimitTier ?? existing?.rateLimitTier ?? null,
-      profile: profileInfo?.rawProfile,
-      tokenAccount: data.account ? {
-        uuid: data.account.uuid,
-        emailAddress: data.account.email_address,
-        organizationUuid: data.organization?.uuid
-      } : undefined
-    };
-  } catch (error) {
-    const responseBody = axios_default.isAxiosError(error) && error.response?.data ? JSON.stringify(error.response.data) : undefined;
-    logEvent("tengu_oauth_token_refresh_failure", {
-      error: error.message,
-      ...responseBody && {
-        responseBody
-      }
-    });
-    throw error;
-  }
-}
-async function fetchAndStoreUserRoles(accessToken) {
-  const response = await axios_default.get(getOauthConfig().ROLES_URL, {
-    headers: { Authorization: `Bearer ${accessToken}` }
-  });
-  if (response.status !== 200) {
-    throw new Error(`Failed to fetch user roles: ${response.statusText}`);
-  }
-  const data = response.data;
-  const config = getGlobalConfig();
-  if (!config.oauthAccount) {
-    throw new Error("OAuth account information not found in config");
-  }
-  saveGlobalConfig((current) => ({
-    ...current,
-    oauthAccount: current.oauthAccount ? {
-      ...current.oauthAccount,
-      organizationRole: data.organization_role,
-      workspaceRole: data.workspace_role,
-      organizationName: data.organization_name
-    } : current.oauthAccount
-  }));
-  logEvent("tengu_oauth_roles_stored", {
-    org_role: data.organization_role
-  });
-}
-async function createAndStoreApiKey(accessToken) {
-  try {
-    const response = await axios_default.post(getOauthConfig().API_KEY_URL, null, {
-      headers: { Authorization: `Bearer ${accessToken}` }
-    });
-    const apiKey = response.data?.raw_key;
-    if (apiKey) {
-      await saveApiKey(apiKey);
-      logEvent("tengu_oauth_api_key", {
-        status: "success",
-        statusCode: response.status
-      });
-      return apiKey;
-    }
-    return null;
-  } catch (error) {
-    logEvent("tengu_oauth_api_key", {
-      status: "failure",
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-function isOAuthTokenExpired(expiresAt) {
-  if (expiresAt === null) {
-    return false;
-  }
-  const bufferTime = 5 * 60 * 1000;
-  const now = Date.now();
-  const expiresWithBuffer = now + bufferTime;
-  return expiresWithBuffer >= expiresAt;
-}
-async function fetchProfileInfo(accessToken) {
-  const profile = await getOauthProfileFromOauthToken(accessToken);
-  const orgType = profile?.organization?.organization_type;
-  let subscriptionType = null;
-  switch (orgType) {
-    case "claude_max":
-      subscriptionType = "max";
-      break;
-    case "claude_pro":
-      subscriptionType = "pro";
-      break;
-    case "claude_enterprise":
-      subscriptionType = "enterprise";
-      break;
-    case "claude_team":
-      subscriptionType = "team";
-      break;
-    default:
-      subscriptionType = null;
-      break;
-  }
-  const result = {
-    subscriptionType,
-    rateLimitTier: profile?.organization?.rate_limit_tier ?? null,
-    hasExtraUsageEnabled: profile?.organization?.has_extra_usage_enabled ?? null,
-    billingType: profile?.organization?.billing_type ?? null
-  };
-  if (profile?.account?.display_name) {
-    result.displayName = profile.account.display_name;
-  }
-  if (profile?.account?.created_at) {
-    result.accountCreatedAt = profile.account.created_at;
-  }
-  if (profile?.organization?.subscription_created_at) {
-    result.subscriptionCreatedAt = profile.organization.subscription_created_at;
-  }
-  logEvent("tengu_oauth_profile_fetch_success", {});
-  return { ...result, rawProfile: profile };
-}
-async function getOrganizationUUID() {
-  const globalConfig = getGlobalConfig();
-  const orgUUID = globalConfig.oauthAccount?.organizationUuid;
-  if (orgUUID) {
-    return orgUUID;
-  }
-  const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-  if (accessToken === undefined || !hasProfileScope()) {
-    return null;
-  }
-  const profile = await getOauthProfileFromOauthToken(accessToken);
-  const profileOrgUUID = profile?.organization?.uuid;
-  if (!profileOrgUUID) {
-    return null;
-  }
-  return profileOrgUUID;
-}
-function storeOAuthAccountInfo({
-  accountUuid,
-  emailAddress,
-  organizationUuid,
-  displayName,
-  hasExtraUsageEnabled,
-  billingType,
-  accountCreatedAt,
-  subscriptionCreatedAt
-}) {
-  const accountInfo = {
-    accountUuid,
-    emailAddress,
-    organizationUuid,
-    hasExtraUsageEnabled,
-    billingType,
-    accountCreatedAt,
-    subscriptionCreatedAt
-  };
-  if (displayName) {
-    accountInfo.displayName = displayName;
-  }
-  saveGlobalConfig((current) => {
-    if (current.oauthAccount?.accountUuid === accountInfo.accountUuid && current.oauthAccount?.emailAddress === accountInfo.emailAddress && current.oauthAccount?.organizationUuid === accountInfo.organizationUuid && current.oauthAccount?.displayName === accountInfo.displayName && current.oauthAccount?.hasExtraUsageEnabled === accountInfo.hasExtraUsageEnabled && current.oauthAccount?.billingType === accountInfo.billingType && current.oauthAccount?.accountCreatedAt === accountInfo.accountCreatedAt && current.oauthAccount?.subscriptionCreatedAt === accountInfo.subscriptionCreatedAt) {
-      return current;
-    }
-    return { ...current, oauthAccount: accountInfo };
-  });
-}
-var init_client = __esm(() => {
-  init_axios();
-  init_analytics();
-  init_oauth();
-  init_auth();
-  init_config();
-  init_debug();
-  init_getOauthProfile();
-});
-
-// src/utils/teleport/api.ts
-import { randomUUID } from "crypto";
-function isTransientNetworkError(error) {
-  if (!axios_default.isAxiosError(error)) {
-    return false;
-  }
-  if (!error.response) {
-    return true;
-  }
-  if (error.response.status >= 500) {
-    return true;
-  }
-  return false;
-}
-async function axiosGetWithRetry(url, config) {
-  let lastError;
-  for (let attempt = 0;attempt <= MAX_TELEPORT_RETRIES; attempt++) {
-    try {
-      return await axios_default.get(url, config);
-    } catch (error) {
-      lastError = error;
-      if (!isTransientNetworkError(error)) {
-        throw error;
-      }
-      if (attempt >= MAX_TELEPORT_RETRIES) {
-        logForDebugging(`Teleport request failed after ${attempt + 1} attempts: ${errorMessage(error)}`);
-        throw error;
-      }
-      const delay = TELEPORT_RETRY_DELAYS[attempt] ?? 2000;
-      logForDebugging(`Teleport request failed (attempt ${attempt + 1}/${MAX_TELEPORT_RETRIES + 1}), retrying in ${delay}ms: ${errorMessage(error)}`);
-      await sleep(delay);
-    }
-  }
-  throw lastError;
-}
-async function prepareApiRequest() {
-  const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-  if (accessToken === undefined) {
-    throw new Error("Claude Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.");
-  }
-  const orgUUID = await getOrganizationUUID();
-  if (!orgUUID) {
-    throw new Error("Unable to get organization UUID");
-  }
-  return { accessToken, orgUUID };
-}
-async function fetchCodeSessionsFromSessionsAPI() {
-  const { accessToken, orgUUID } = await prepareApiRequest();
-  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions`;
-  try {
-    const headers = {
-      ...getOAuthHeaders(accessToken),
-      "anthropic-beta": "ccr-byoc-2025-07-29",
-      "x-organization-uuid": orgUUID
-    };
-    const response = await axiosGetWithRetry(url, {
-      headers
-    });
-    if (response.status !== 200) {
-      throw new Error(`Failed to fetch code sessions: ${response.statusText}`);
-    }
-    const sessions = response.data.data.map((session) => {
-      const gitSource = session.session_context.sources.find((source) => source.type === "git_repository");
-      let repo = null;
-      if (gitSource?.url) {
-        const repoPath = parseGitHubRepository(gitSource.url);
-        if (repoPath) {
-          const [owner, name] = repoPath.split("/");
-          if (owner && name) {
-            repo = {
-              name,
-              owner: {
-                login: owner
-              },
-              default_branch: gitSource.revision || undefined
-            };
-          }
-        }
-      }
-      return {
-        id: session.id,
-        title: session.title || "Untitled",
-        description: "",
-        status: session.session_status,
-        repo,
-        turns: [],
-        created_at: session.created_at,
-        updated_at: session.updated_at
-      };
-    });
-    return sessions;
-  } catch (error) {
-    const err = toError(error);
-    logError(err);
-    throw error;
-  }
-}
-function getOAuthHeaders(accessToken) {
-  return {
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "anthropic-version": "2023-06-01"
-  };
-}
-async function fetchSession(sessionId) {
-  const { accessToken, orgUUID } = await prepareApiRequest();
-  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
-  const headers = {
-    ...getOAuthHeaders(accessToken),
-    "anthropic-beta": "ccr-byoc-2025-07-29",
-    "x-organization-uuid": orgUUID
-  };
-  const response = await axios_default.get(url, {
-    headers,
-    timeout: 15000,
-    validateStatus: (status) => status < 500
-  });
-  if (response.status !== 200) {
-    const errorData = response.data;
-    const apiMessage = errorData?.error?.message;
-    if (response.status === 404) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    if (response.status === 401) {
-      throw new Error("Session expired. Please run /login to sign in again.");
-    }
-    throw new Error(apiMessage || `Failed to fetch session: ${response.status} ${response.statusText}`);
-  }
-  return response.data;
-}
-function getBranchFromSession(session) {
-  const gitOutcome = session.session_context.outcomes?.find((outcome) => outcome.type === "git_repository");
-  return gitOutcome?.git_info?.branches[0];
-}
-async function sendEventToRemoteSession(sessionId, messageContent, opts) {
-  try {
-    const { accessToken, orgUUID } = await prepareApiRequest();
-    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/events`;
-    const headers = {
-      ...getOAuthHeaders(accessToken),
-      "anthropic-beta": "ccr-byoc-2025-07-29",
-      "x-organization-uuid": orgUUID
-    };
-    const userEvent = {
-      uuid: opts?.uuid ?? randomUUID(),
-      session_id: sessionId,
-      type: "user",
-      parent_tool_use_id: null,
-      message: {
-        role: "user",
-        content: messageContent
-      }
-    };
-    const requestBody = {
-      events: [userEvent]
-    };
-    logForDebugging(`[sendEventToRemoteSession] Sending event to session ${sessionId}`);
-    const response = await axios_default.post(url, requestBody, {
-      headers,
-      validateStatus: (status) => status < 500,
-      timeout: 30000
-    });
-    if (response.status === 200 || response.status === 201) {
-      logForDebugging(`[sendEventToRemoteSession] Successfully sent event to session ${sessionId}`);
-      return true;
-    }
-    logForDebugging(`[sendEventToRemoteSession] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
-    return false;
-  } catch (error) {
-    logForDebugging(`[sendEventToRemoteSession] Error: ${errorMessage(error)}`);
-    return false;
-  }
-}
-async function updateSessionTitle(sessionId, title) {
-  try {
-    const { accessToken, orgUUID } = await prepareApiRequest();
-    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
-    const headers = {
-      ...getOAuthHeaders(accessToken),
-      "anthropic-beta": "ccr-byoc-2025-07-29",
-      "x-organization-uuid": orgUUID
-    };
-    logForDebugging(`[updateSessionTitle] Updating title for session ${sessionId}: "${title}"`);
-    const response = await axios_default.patch(url, { title }, {
-      headers,
-      validateStatus: (status) => status < 500
-    });
-    if (response.status === 200) {
-      logForDebugging(`[updateSessionTitle] Successfully updated title for session ${sessionId}`);
-      return true;
-    }
-    logForDebugging(`[updateSessionTitle] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
-    return false;
-  } catch (error) {
-    logForDebugging(`[updateSessionTitle] Error: ${errorMessage(error)}`);
-    return false;
-  }
-}
-var TELEPORT_RETRY_DELAYS, MAX_TELEPORT_RETRIES, CodeSessionSchema;
-var init_api = __esm(() => {
-  init_axios();
-  init_oauth();
-  init_client();
-  init_v4();
-  init_auth();
-  init_debug();
-  init_detectRepository();
-  init_errors();
-  init_lazySchema();
-  init_log();
-  init_sleep();
-  init_slowOperations();
-  TELEPORT_RETRY_DELAYS = [2000, 4000, 8000, 16000];
-  MAX_TELEPORT_RETRIES = TELEPORT_RETRY_DELAYS.length;
-  CodeSessionSchema = lazySchema(() => v4_default.object({
-    id: v4_default.string(),
-    title: v4_default.string(),
-    description: v4_default.string(),
-    status: v4_default.enum([
-      "idle",
-      "working",
-      "waiting",
-      "completed",
-      "archived",
-      "cancelled",
-      "rejected"
-    ]),
-    repo: v4_default.object({
-      name: v4_default.string(),
-      owner: v4_default.object({
-        login: v4_default.string()
-      }),
-      default_branch: v4_default.string().optional()
-    }).nullable(),
-    turns: v4_default.array(v4_default.string()),
-    created_at: v4_default.string(),
-    updated_at: v4_default.string()
-  }));
-});
-
-export { getOauthProfileFromApiKey, getOauthProfileFromOauthToken, init_getOauthProfile, shouldUseClaudeAIAuth, parseScopes, buildAuthUrl, exchangeCodeForTokens, refreshOAuthToken, fetchAndStoreUserRoles, createAndStoreApiKey, isOAuthTokenExpired, fetchProfileInfo, getOrganizationUUID, storeOAuthAccountInfo, init_client, isTransientNetworkError, prepareApiRequest, fetchCodeSessionsFromSessionsAPI, getOAuthHeaders, fetchSession, getBranchFromSession, sendEventToRemoteSession, updateSessionTitle, init_api };