@opengeni/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1196 @@
+type SessionStatus = "queued" | "running" | "idle" | "requires_action" | "failed" | "cancelled";
+type SandboxBackend = "docker" | "modal" | "local" | "none";
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+type RepositoryResourceRef = {
+    kind: "repository";
+    uri: string;
+    ref: string;
+    mountPath?: string | undefined;
+    subpath?: string | undefined;
+    githubInstallationId?: number | undefined;
+    githubRepositoryId?: number | undefined;
+};
+type FileResourceRef = {
+    kind: "file";
+    fileId: string;
+    mountPath?: string | undefined;
+};
+type ResourceRef = RepositoryResourceRef | FileResourceRef;
+type ToolRef = {
+    kind: "mcp";
+    id: string;
+};
+type GoalSpec = {
+    text: string;
+    successCriteria?: string | undefined;
+    maxAutoContinuations?: number | undefined;
+};
+type Session = {
+    id: string;
+    workspaceId: string;
+    accountId: string;
+    status: SessionStatus;
+    initialMessage: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    metadata: Record<string, unknown>;
+    model: string;
+    sandboxBackend: SandboxBackend;
+    environmentId: string | null;
+    firstPartyMcpPermissions: string[] | null;
+    createIdempotencyKey: string | null;
+    temporalWorkflowId: string | null;
+    activeTurnId: string | null;
+    lastSequence: number;
+    createdAt: string;
+    updatedAt: string;
+};
+type SessionTurnStatus = "queued" | "running" | "requires_action" | "completed" | "failed" | "cancelled";
+type SessionTurnSource = "user" | "scheduled_task" | "api" | "goal";
+type SessionTurn = {
+    id: string;
+    workspaceId: string;
+    sessionId: string;
+    triggerEventId: string;
+    temporalWorkflowId: string;
+    status: SessionTurnStatus;
+    source: SessionTurnSource;
+    position: number;
+    prompt: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    model: string;
+    reasoningEffort: ReasoningEffort;
+    sandboxBackend: SandboxBackend;
+    metadata: Record<string, unknown>;
+    startedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+declare const SESSION_EVENT_TYPES: readonly ["session.created", "session.status.changed", "session.requiresAction", "session.context.compacted", "session.context.cleared", "user.message", "user.interrupt", "user.approvalDecision", "turn.queued", "turn.updated", "turn.started", "turn.completed", "turn.failed", "turn.cancelled", "turn.preempted", "agent.message.delta", "agent.message.completed", "agent.reasoning.delta", "agent.toolCall.created", "agent.toolCall.output", "agent.updated", "sandbox.operation.started", "sandbox.operation.completed", "sandbox.operation.failed", "sandbox.command.output.delta", "artifact.created", "goal.set", "goal.updated", "goal.completed", "goal.paused", "goal.resumed", "goal.continuation"];
+type KnownSessionEventType = (typeof SESSION_EVENT_TYPES)[number];
+/**
+ * Event types the SDK knows about today, kept open so a newer OpenGeni server
+ * can introduce event types without breaking older SDK consumers.
+ */
+type SessionEventType = KnownSessionEventType | (string & {});
+type SessionEvent = {
+    id: string;
+    workspaceId: string;
+    sessionId: string;
+    /** Per-session sequence number: positive, contiguous, strictly increasing. */
+    sequence: number;
+    type: SessionEventType;
+    payload: unknown;
+    occurredAt: string;
+    clientEventId?: string | null | undefined;
+    turnId?: string | null | undefined;
+};
+type AgentTextDeltaPayload = {
+    text: string;
+};
+type AgentMessageCompletedPayload = {
+    text: string;
+};
+type AgentToolCallCreatedPayload = {
+    id: string | null;
+    name: string;
+    arguments: unknown;
+    raw?: unknown | undefined;
+};
+type AgentToolCallOutputPayload = {
+    id: string | null;
+    output: unknown;
+};
+type SessionStatusChangedPayload = {
+    status: SessionStatus;
+};
+type ScheduledTaskStatus = "active" | "paused";
+type ScheduledTaskRunMode = "new_session_per_run" | "reusable_session";
+type ScheduledTaskOverlapPolicy = "allow_concurrent" | "skip" | "buffer_one";
+type ScheduledTaskDayOfWeek = "SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY";
+type ScheduledTaskScheduleSpec = {
+    type: "once";
+    runAt: string;
+    timeZone: string;
+} | {
+    type: "interval";
+    everySeconds: number;
+    startAt?: string | undefined;
+    endAt?: string | undefined;
+} | {
+    type: "calendar";
+    timeZone: string;
+    hour: number;
+    minute: number;
+    daysOfWeek?: ScheduledTaskDayOfWeek[] | undefined;
+};
+type ScheduledTaskAgentConfig = {
+    prompt: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    metadata: Record<string, unknown>;
+    model?: string | undefined;
+    reasoningEffort?: ReasoningEffort | undefined;
+    sandboxBackend?: SandboxBackend | undefined;
+    goal?: GoalSpec | undefined;
+};
+type ScheduledTask = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    status: ScheduledTaskStatus;
+    schedule: ScheduledTaskScheduleSpec;
+    temporalScheduleId: string;
+    runMode: ScheduledTaskRunMode;
+    overlapPolicy: ScheduledTaskOverlapPolicy;
+    agentConfig: ScheduledTaskAgentConfig;
+    reusableSessionId: string | null;
+    environmentId: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateSessionRequest = {
+    initialMessage: string;
+    resources?: ResourceRef[] | undefined;
+    tools?: ToolRef[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    model?: string | undefined;
+    reasoningEffort?: ReasoningEffort | undefined;
+    sandboxBackend?: SandboxBackend | undefined;
+    environmentId?: string | undefined;
+    goal?: GoalSpec | undefined;
+    clientEventId?: string | undefined;
+    idempotencyKey?: string | undefined;
+    firstPartyMcpPermissions?: string[] | undefined;
+};
+declare const KNOWN_PERMISSIONS: readonly ["account:read", "account:admin", "members:manage", "workspace:create", "billing:read", "billing:manage", "workspace:read", "workspace:admin", "sessions:create", "sessions:read", "sessions:control", "files:upload", "files:read", "documents:manage", "documents:search", "scheduled_tasks:manage", "scheduled_tasks:run", "github:manage", "github:use", "api_keys:manage", "environments:manage", "environments:use", "goals:manage"];
+type KnownPermission = (typeof KNOWN_PERMISSIONS)[number];
+/**
+ * Permissions the SDK knows about today, kept open so a newer OpenGeni server
+ * can introduce permissions without breaking older SDK consumers.
+ */
+type Permission = KnownPermission | (string & {});
+type ProductAccessMode = "local" | "configured" | "managed";
+type AccountRole = "owner" | "admin" | "member";
+type AccountGrant = {
+    accountId: string;
+    subjectId: string;
+    subjectLabel?: string | undefined;
+    role?: AccountRole | undefined;
+    permissions: Permission[];
+    metadata?: Record<string, unknown> | undefined;
+};
+type AccessGrant = {
+    workspaceId: string;
+    accountId: string;
+    subjectId: string;
+    subjectLabel?: string | undefined;
+    permissions: Permission[];
+    metadata?: Record<string, unknown> | undefined;
+};
+type AccessContext = {
+    mode: ProductAccessMode;
+    subjectId: string;
+    subjectLabel?: string | undefined;
+    accountGrants: AccountGrant[];
+    workspaceGrants: AccessGrant[];
+    defaultAccountId: string | null;
+    defaultWorkspaceId: string | null;
+};
+type Workspace = {
+    id: string;
+    accountId: string;
+    name: string;
+    slug: string | null;
+    externalSource: string | null;
+    externalId: string | null;
+    agentInstructions: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateWorkspaceRequest = {
+    accountId?: string | undefined;
+    name: string;
+    slug?: string | undefined;
+    externalSource?: string | undefined;
+    externalId?: string | undefined;
+    agentInstructions?: string | null | undefined;
+};
+type UpdateWorkspaceRequest = {
+    name?: string | undefined;
+    slug?: string | null | undefined;
+    agentInstructions?: string | null | undefined;
+};
+type ApiKey = {
+    id: string;
+    accountId: string;
+    workspaceId: string | null;
+    name: string;
+    prefix: string;
+    permissions: Permission[];
+    expiresAt: string | null;
+    revokedAt: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateApiKeyRequest = {
+    name: string;
+    permissions: Permission[];
+    expiresAt?: string | undefined;
+};
+type CreateApiKeyResponse = {
+    apiKey: ApiKey;
+    /** The full secret token — shown once at creation, never returned again. */
+    token: string;
+};
+type ListApiKeysResponse = {
+    apiKeys: ApiKey[];
+};
+type SessionGoalStatus = "active" | "paused" | "completed";
+type SessionGoalCreatedBy = "api" | "agent" | "scheduled_task";
+type SessionGoal = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    status: SessionGoalStatus;
+    text: string;
+    successCriteria: string | null;
+    evidence: string | null;
+    rationale: string | null;
+    pausedReason: string | null;
+    createdBy: SessionGoalCreatedBy;
+    version: number;
+    autoContinuations: number;
+    noProgressStreak: number;
+    maxAutoContinuations: number | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+};
+type UpdateSessionGoalRequest = {
+    status: "paused" | "active";
+    rationale?: string | undefined;
+};
+/** Outcome of a manual /compact trigger. */
+type CompactSessionContextResult = {
+    /**
+     * queued: a client-side (Azure) compaction will run before the next turn.
+     * noop:   nothing to do (server-managed provider, mode off, or no history).
+     */
+    status: "queued" | "noop";
+    message: string;
+};
+type UpdateSessionTurnRequest = {
+    prompt?: string | undefined;
+    resources?: ResourceRef[] | undefined;
+    tools?: ToolRef[] | undefined;
+    model?: string | undefined;
+    reasoningEffort?: ReasoningEffort | undefined;
+    sandboxBackend?: SandboxBackend | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+/** Input shape for agent config on create/update (server applies defaults). */
+type ScheduledTaskAgentConfigInput = {
+    prompt: string;
+    resources?: ResourceRef[] | undefined;
+    tools?: ToolRef[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    model?: string | undefined;
+    reasoningEffort?: ReasoningEffort | undefined;
+    sandboxBackend?: SandboxBackend | undefined;
+    goal?: GoalSpec | undefined;
+};
+type CreateScheduledTaskRequest = {
+    name: string;
+    schedule: ScheduledTaskScheduleSpec;
+    runMode?: ScheduledTaskRunMode | undefined;
+    overlapPolicy?: ScheduledTaskOverlapPolicy | undefined;
+    agentConfig: ScheduledTaskAgentConfigInput;
+    status?: ScheduledTaskStatus | undefined;
+    environmentId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+type UpdateScheduledTaskRequest = {
+    name?: string | undefined;
+    schedule?: ScheduledTaskScheduleSpec | undefined;
+    runMode?: ScheduledTaskRunMode | undefined;
+    overlapPolicy?: ScheduledTaskOverlapPolicy | undefined;
+    agentConfig?: ScheduledTaskAgentConfigInput | undefined;
+    status?: ScheduledTaskStatus | undefined;
+    environmentId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+type ScheduledTaskRunStatus = "queued" | "dispatched" | "failed";
+type ScheduledTaskTriggerType = "scheduled" | "manual";
+type ScheduledTaskRun = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    taskId: string;
+    status: ScheduledTaskRunStatus;
+    triggerType: ScheduledTaskTriggerType;
+    scheduledAt: string | null;
+    firedAt: string;
+    sessionId: string | null;
+    triggerEventId: string | null;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * Variable values are write-only by design: the API never returns a value, so
+ * reads expose name + version metadata only. Values are decrypted exclusively
+ * inside the worker at sandbox materialization time.
+ */
+type WorkspaceEnvironmentVariableMetadata = {
+    name: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+};
+type WorkspaceEnvironment = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    description: string | null;
+    variables: WorkspaceEnvironmentVariableMetadata[];
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateWorkspaceEnvironmentRequest = {
+    name: string;
+    description?: string | undefined;
+    /** Initial variables. Values are write-only: they never come back on reads. */
+    variables?: {
+        name: string;
+        value: string;
+    }[] | undefined;
+};
+type UpdateWorkspaceEnvironmentRequest = {
+    name?: string | undefined;
+    description?: string | null | undefined;
+};
+type FileStatus = "pending_upload" | "ready" | "failed" | "expired" | "deleted";
+type FileAsset = {
+    id: string;
+    workspaceId: string;
+    status: FileStatus;
+    filename: string;
+    safeFilename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string | null;
+    bucket: string;
+    objectKey: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateFileUploadRequest = {
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256?: string | undefined;
+};
+type CreateFileUploadResponse = {
+    fileId: string;
+    uploadId: string;
+    /** Pre-signed PUT URL for the file bytes (direct to object storage). */
+    putUrl: string;
+    /** Headers that MUST be sent with the PUT for the signature to validate. */
+    requiredHeaders: Record<string, string>;
+    expiresAt: string;
+    maxSizeBytes: number;
+};
+type CompleteFileUploadResponse = {
+    file: FileAsset;
+};
+type FileDownloadUrlResponse = {
+    url: string;
+    expiresAt: string;
+};
+/** Bytes accepted by the `uploadFile` helper. */
+type FileUploadData = Blob | ArrayBuffer | Uint8Array | string;
+type UploadFileInput = {
+    filename: string;
+    contentType: string;
+    data: FileUploadData;
+    sha256?: string | undefined;
+};
+type DocumentStatus = "queued" | "indexing" | "ready" | "failed";
+type DocumentBase = {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type Document = {
+    id: string;
+    workspaceId: string;
+    baseId: string;
+    fileId: string;
+    status: DocumentStatus;
+    title: string;
+    parser: string;
+    chunkCount: number;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type DocumentSearchResult = {
+    chunkId: string;
+    workspaceId: string;
+    documentId: string;
+    baseId: string;
+    fileId: string;
+    title: string;
+    text: string;
+    score: number;
+    chunkIndex: number;
+    metadata: Record<string, unknown>;
+};
+type CreateDocumentBaseRequest = {
+    name: string;
+    description?: string | undefined;
+};
+type DocumentSearchRequest = {
+    query: string;
+    limit?: number | undefined;
+};
+type DocumentSearchResponse = {
+    results: DocumentSearchResult[];
+};
+type CapabilityPackConnectorAuthModel = "oauth2_authorization_code_pkce" | "oauth2_authorization_code" | "api_key" | "credential_ref";
+type CapabilityPackConnector = {
+    id: string;
+    name: string;
+    category: string;
+    authModel: CapabilityPackConnectorAuthModel;
+    providers: string[];
+    scopes: string[];
+    required: boolean;
+    metadata: Record<string, unknown>;
+};
+type CapabilityPackKnowledge = {
+    type: "document_base";
+    id: string;
+    name: string;
+    description: string | null;
+    required: boolean;
+};
+type CapabilityPackScheduledTaskTemplate = {
+    id: string;
+    name: string;
+    description: string;
+    defaultSchedule: ScheduledTaskScheduleSpec;
+    defaultRunMode: ScheduledTaskRunMode;
+    defaultOverlapPolicy: ScheduledTaskOverlapPolicy;
+    prompt?: string | undefined;
+};
+type CapabilityPackSkillFile = {
+    path: string;
+    content: string;
+};
+type CapabilityPackSkill = {
+    name: string;
+    description?: string | undefined;
+    files: CapabilityPackSkillFile[];
+};
+type CapabilityPackEnvironmentSpec = {
+    description: string;
+    requiredVariables: string[];
+    required: boolean;
+};
+type CapabilityPack = {
+    id: string;
+    name: string;
+    description: string;
+    role: string;
+    category: string;
+    version: string;
+    sandboxImage?: string | undefined;
+    skills: CapabilityPackSkill[];
+    tools: ToolRef[];
+    connectors: CapabilityPackConnector[];
+    knowledge: CapabilityPackKnowledge[];
+    scheduledTaskTemplates: CapabilityPackScheduledTaskTemplate[];
+    environment?: CapabilityPackEnvironmentSpec | undefined;
+    metadata: Record<string, unknown>;
+};
+/** Input shape for registering a pack manifest (server applies defaults). */
+type RegisterCapabilityPackRequest = {
+    id: string;
+    name: string;
+    description: string;
+    role: string;
+    category: string;
+    version: string;
+    sandboxImage?: string | undefined;
+    skills?: {
+        name: string;
+        description?: string | undefined;
+        files: CapabilityPackSkillFile[];
+    }[] | undefined;
+    tools?: ToolRef[] | undefined;
+    connectors?: {
+        id: string;
+        name: string;
+        category: string;
+        authModel: CapabilityPackConnectorAuthModel;
+        providers?: string[] | undefined;
+        scopes?: string[] | undefined;
+        required?: boolean | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    knowledge?: {
+        type: "document_base";
+        id: string;
+        name: string;
+        description?: string | null | undefined;
+        required?: boolean | undefined;
+    }[] | undefined;
+    scheduledTaskTemplates?: {
+        id: string;
+        name: string;
+        description: string;
+        defaultSchedule: ScheduledTaskScheduleSpec;
+        defaultRunMode?: ScheduledTaskRunMode | undefined;
+        defaultOverlapPolicy?: ScheduledTaskOverlapPolicy | undefined;
+        prompt?: string | undefined;
+    }[] | undefined;
+    environment?: {
+        description: string;
+        requiredVariables?: string[] | undefined;
+        required?: boolean | undefined;
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+type WorkspaceRegisteredPack = {
+    accountId: string;
+    workspaceId: string;
+    pack: CapabilityPack;
+    createdAt: string;
+    updatedAt: string;
+};
+type PackInstallationStatus = "active" | "disabled";
+type PackInstallation = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    packId: string;
+    status: PackInstallationStatus;
+    metadata: Record<string, unknown>;
+    enabledAt: string;
+    updatedAt: string;
+};
+type EnablePackRequest = {
+    environmentId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+type ListPacksResponse = {
+    packs: CapabilityPack[];
+    installations: PackInstallation[];
+};
+type GetPackResponse = {
+    pack: CapabilityPack;
+    installation: PackInstallation | null;
+};
+type CapabilityKind = "pack" | "mcp" | "api" | "skill" | "plugin";
+type CapabilitySource = "built_in" | "configured" | "public_registry" | "manual";
+type CapabilityInstallationStatus = "active" | "disabled";
+type CapabilityRuntime = {
+    available: boolean;
+    mcpServerId?: string | undefined;
+    transport?: string | undefined;
+    notes: string | null;
+};
+type CapabilityCatalogItem = {
+    id: string;
+    accountId?: string | undefined;
+    workspaceId?: string | undefined;
+    kind: CapabilityKind;
+    source: CapabilitySource;
+    name: string;
+    description: string | null;
+    category: string;
+    tags: string[];
+    homepageUrl: string | null;
+    endpointUrl: string | null;
+    installUrl: string | null;
+    authModel: string | null;
+    tools: ToolRef[];
+    runtime: CapabilityRuntime;
+    enabled: boolean;
+    enabledReason: string | null;
+    metadata: Record<string, unknown>;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+};
+type CapabilityInstallation = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    capabilityId: string;
+    kind: CapabilityKind;
+    status: CapabilityInstallationStatus;
+    config: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    enabledAt: string;
+    updatedAt: string;
+};
+type CapabilityCatalogResponse = {
+    items: CapabilityCatalogItem[];
+    installations: CapabilityInstallation[];
+};
+type CreateCapabilityCatalogItemRequest = {
+    id?: string | undefined;
+    kind: Exclude<CapabilityKind, "pack">;
+    source?: CapabilitySource | undefined;
+    name: string;
+    description?: string | undefined;
+    category?: string | undefined;
+    tags?: string[] | undefined;
+    homepageUrl?: string | undefined;
+    endpointUrl?: string | undefined;
+    installUrl?: string | undefined;
+    authModel?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+type EnableCapabilityRequest = {
+    config?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    /**
+     * Credential headers for remote MCP capabilities. Write-only: encrypted at
+     * rest, injected only into the runtime MCP client, never returned by the
+     * API (responses expose header names only).
+     */
+    headers?: Record<string, string> | undefined;
+    /**
+     * Initial environment attachment for kind=pack capabilities — mirrors the
+     * dedicated POST /packs/:id/enable body. Required to enable an
+     * environment.required pack through this unified path; ignored otherwise.
+     */
+    environmentId?: string | undefined;
+};
+type DiscoverMcpCapabilitiesResponse = {
+    items: CapabilityCatalogItem[];
+    source: "official_mcp_registry";
+    sourceUrl: string;
+};
+type GitHubRepository = {
+    id: number;
+    installationId: number;
+    fullName: string;
+    name: string;
+    private: boolean;
+    htmlUrl: string;
+    cloneUrl: string;
+    defaultBranch: string;
+    accountLogin: string;
+    accountType: string | null;
+};
+type GitHubAppInfo = {
+    configured: boolean;
+    appId: string | null;
+    clientId: string | null;
+    appSlug: string | null;
+    /** Ready-to-open GitHub install URL (carries the signed state), if configured. */
+    installUrl: string | null;
+    /** Setting names still missing when `configured` is false. */
+    missing: string[];
+};
+type GitHubRepositoriesResponse = {
+    repositories: GitHubRepository[];
+};
+type CreateGitHubAppManifestRequest = {
+    appName?: string | undefined;
+    organization?: string | undefined;
+    public?: boolean | undefined;
+    includeCiPermissions?: boolean | undefined;
+};
+type CreateGitHubAppManifestResponse = {
+    /** GitHub URL to POST the manifest to (personal or organization flow). */
+    actionUrl: string;
+    state: string;
+    manifest: Record<string, unknown>;
+};
+type BillingMode = "disabled" | "stripe";
+type EntitlementsMode = "none" | "static" | "managed";
+type BillingBalance = {
+    accountId: string;
+    balanceMicros: number;
+    currency: "usd";
+    updatedAt: string;
+};
+declare const KNOWN_USAGE_EVENT_TYPES: readonly ["agent_run.created", "agent_run.completed", "model.tokens", "model.cost", "file.uploaded", "file.deleted", "document.indexed", "scheduled_task.fired", "api_key.request"];
+type KnownUsageEventType = (typeof KNOWN_USAGE_EVENT_TYPES)[number];
+type UsageEventType = KnownUsageEventType | (string & {});
+type UsageEvent = {
+    id: string;
+    workspaceId: string;
+    accountId: string;
+    subjectId: string | null;
+    eventType: UsageEventType;
+    quantity: number;
+    unit: string;
+    sourceResourceType: string | null;
+    sourceResourceId: string | null;
+    idempotencyKey: string;
+    occurredAt: string;
+    recordedAt: string;
+    exportedToBillingAt: string | null;
+    billingProviderEventId: string | null;
+};
+type EntitlementValue = boolean | string | number | string[];
+type Entitlements = Record<string, EntitlementValue>;
+type BillingSummary = {
+    mode: BillingMode;
+    balance: BillingBalance;
+};
+type BillingUsageResponse = {
+    balance: BillingBalance;
+    usage: UsageEvent[];
+};
+type BillingEntitlementsResponse = {
+    accountId: string;
+    mode: EntitlementsMode;
+    entitlements: Entitlements;
+};
+type CreateCheckoutRequest = {
+    accountId?: string | undefined;
+    /** USD amount with cent precision (server enforces min/max). */
+    amountUsd: number;
+    successUrl?: string | undefined;
+    cancelUrl?: string | undefined;
+};
+type CreateCheckoutResponse = {
+    checkoutSessionId: string;
+    url: string;
+};
+type UserMessageEventInput = {
+    type: "user.message";
+    clientEventId?: string | undefined;
+    payload: {
+        text: string;
+        resources?: ResourceRef[] | undefined;
+        tools?: ToolRef[] | undefined;
+        model?: string | undefined;
+        reasoningEffort?: ReasoningEffort | undefined;
+    };
+};
+type UserInterruptEventInput = {
+    type: "user.interrupt";
+    clientEventId?: string | undefined;
+    payload?: {
+        reason?: string | undefined;
+    } | undefined;
+};
+type UserApprovalDecisionEventInput = {
+    type: "user.approvalDecision";
+    clientEventId?: string | undefined;
+    payload: {
+        approvalId: string;
+        decision: "approve" | "reject";
+        message?: string | undefined;
+    };
+};
+/** Control/user events a client may POST to a session's event log. */
+type ClientSessionEventInput = UserMessageEventInput | UserInterruptEventInput | UserApprovalDecisionEventInput;
+
+/**
+ * Transport boundary for the streaming core. The client implements it with
+ * `fetch`; unit tests script it directly.
+ */
+type SessionEventStreamTransport = {
+    /** Open the SSE stream, replaying durable events after `after` first. */
+    openStream: (after: number, signal: AbortSignal | undefined) => Promise<ReadableStream<Uint8Array>>;
+    /** Replay durable events by sequence (`GET .../events?after=&limit=`). */
+    listEvents: (after: number, limit: number) => Promise<SessionEvent[]>;
+};
+type StreamConnectionState = "connecting" | "live" | "reconnecting";
+type StreamSessionEventsOptions = {
+    /** Resume after this sequence number (exclusive). Defaults to 0 (full replay). */
+    after?: number;
+    /** Aborting ends the stream gracefully (the generator returns). */
+    signal?: AbortSignal;
+    /** Reconnect on transient drops. Defaults to true. */
+    reconnect?: boolean;
+    /** Initial reconnect backoff. Defaults to 500ms. */
+    reconnectDelayMs?: number;
+    /** Backoff ceiling. Defaults to 10s. */
+    maxReconnectDelayMs?: number;
+    /**
+     * Give up after this many consecutive failed reconnect attempts (i.e. N
+     * reconnects = N+1 total open-stream calls). Defaults to unlimited.
+     */
+    maxReconnectAttempts?: number;
+    onStateChange?: (state: StreamConnectionState) => void;
+};
+/**
+ * Stream a session's events with exactly-once, in-order delivery.
+ *
+ * Guarantees, anchored on the per-session contiguous `sequence`:
+ * - **No duplicates**: events at or below the cursor are dropped, so server
+ *   replay overlap and reconnect overlap never re-yield.
+ * - **No gaps**: each reconnect resumes from the last seen sequence, and a
+ *   gap observed inside one connection is backfilled from the durable replay
+ *   endpoint before the newer event is yielded (events are durable before
+ *   they are published live, so the backfill always finds them).
+ * - **Ordered**: sequences are yielded strictly ascending.
+ *
+ * The generator ends when `signal` aborts, when the server closes and
+ * `reconnect` is false, or with an error for non-retryable failures.
+ */
+declare function streamSessionEvents(transport: SessionEventStreamTransport, options?: StreamSessionEventsOptions): AsyncGenerator<SessionEvent, void, void>;
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type OpenGeniClientOptions = {
+    /** Base URL of the OpenGeni API, e.g. `https://api.example.com`. */
+    baseUrl: string;
+    /** OpenGeni API key, sent as `Authorization: Bearer <apiKey>`. */
+    apiKey?: string;
+    /** Extra headers (static or computed per request) merged into every call. */
+    headers?: Record<string, string> | (() => Record<string, string>);
+    /** Custom fetch implementation. Defaults to the global `fetch`. */
+    fetch?: FetchLike;
+};
+type SendMessageInput = {
+    text: string;
+    resources?: ResourceRef[];
+    tools?: ToolRef[];
+    model?: string;
+    reasoningEffort?: ReasoningEffort;
+    clientEventId?: string;
+};
+type SteerMessageResult = {
+    /** The accepted `user.message` event. */
+    accepted: SessionEvent;
+    /**
+     * The turn created for the message, when it could be located — usually
+     * still queued, but already claimed (running/requires_action or even
+     * finished) when the worker picked it up mid-call.
+     */
+    turn: SessionTurn | null;
+    /** True when the running turn was interrupted to make way for the message. */
+    interrupted: boolean;
+};
+/**
+ * Typed client for the OpenGeni public API. Framework-agnostic: only needs
+ * WHATWG `fetch` + streams, so it runs in Node 18+, Bun, Deno, browsers, and
+ * edge runtimes.
+ */
+declare class OpenGeniClient {
+    private readonly baseUrl;
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: OpenGeniClientOptions);
+    createSession(workspaceId: string, request: CreateSessionRequest): Promise<Session>;
+    getSession(workspaceId: string, sessionId: string): Promise<Session>;
+    listSessions(workspaceId: string, options?: {
+        limit?: number;
+    }): Promise<Session[]>;
+    listTurns(workspaceId: string, sessionId: string, options?: {
+        limit?: number;
+    }): Promise<SessionTurn[]>;
+    listScheduledTasks(workspaceId: string, options?: {
+        limit?: number;
+    }): Promise<ScheduledTask[]>;
+    getScheduledTask(workspaceId: string, taskId: string): Promise<ScheduledTask>;
+    /** Replay durable events by sequence: events with `sequence > after`, ascending. */
+    listEvents(workspaceId: string, sessionId: string, options?: {
+        after?: number;
+        limit?: number;
+    }): Promise<SessionEvent[]>;
+    /** POST a user/control event to the session. Returns the accepted event. */
+    sendEvent(workspaceId: string, sessionId: string, event: ClientSessionEventInput): Promise<SessionEvent>;
+    sendMessage(workspaceId: string, sessionId: string, message: string | SendMessageInput): Promise<SessionEvent>;
+    interrupt(workspaceId: string, sessionId: string, options?: {
+        reason?: string;
+        clientEventId?: string;
+    }): Promise<SessionEvent>;
+    sendApprovalDecision(workspaceId: string, sessionId: string, decision: {
+        approvalId: string;
+        decision: "approve" | "reject";
+        message?: string;
+        clientEventId?: string;
+    }): Promise<SessionEvent>;
+    /**
+     * Live-stream a session's events with automatic reconnect, resume from the
+     * last seen sequence, gap backfill, and duplicate suppression. See
+     * {@link streamSessionEvents} for the delivery guarantees.
+     */
+    streamEvents(workspaceId: string, sessionId: string, options?: StreamSessionEventsOptions): AsyncGenerator<SessionEvent, void, void>;
+    /** The transport `streamEvents` runs on; useful for custom streaming layers. */
+    eventStreamTransport(workspaceId: string, sessionId: string): SessionEventStreamTransport;
+    /** Open one raw SSE connection (no reconnect). Most callers want `streamEvents`. */
+    openEventStream(workspaceId: string, sessionId: string, options?: {
+        after?: number;
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array>>;
+    /** Edit a still-queued turn (prompt, model, resources, tools, ...). */
+    updateQueuedTurn(workspaceId: string, sessionId: string, turnId: string, update: UpdateSessionTurnRequest): Promise<SessionTurn>;
+    /**
+     * Reorder the queued turns. `turnIds` must all reference queued turns; the
+     * server assigns positions in the given order and returns the queue.
+     */
+    reorderQueuedTurns(workspaceId: string, sessionId: string, turnIds: string[]): Promise<SessionTurn[]>;
+    /** Cancel a queued turn before it is claimed. Returns the cancelled turn. */
+    deleteQueuedTurn(workspaceId: string, sessionId: string, turnId: string): Promise<SessionTurn>;
+    /**
+     * Steer: deliver a message *now* instead of behind the queue. Sends the
+     * message, promotes its queued turn to the front, and interrupts the
+     * running turn so the session picks the steer turn up next. On a session
+     * that is not running this degrades gracefully to a plain queued message.
+     *
+     * The steer turn is located by `triggerEventId` across ALL turns (retried
+     * briefly in case the server is still materializing it) — not just the
+     * queued ones, because the worker can claim the steer turn before it is
+     * ever observed queued, and a claimed steer turn means the message is
+     * already being delivered: interrupting then would cancel the very message
+     * being steered. If the turn cannot be found while other turns are queued,
+     * the interrupt is also skipped — stopping the running turn would otherwise
+     * promote someone else's queued work over this message — and the call
+     * degrades to a plain queued send (`interrupted: false`).
+     */
+    steerMessage(workspaceId: string, sessionId: string, message: string | SendMessageInput): Promise<SteerMessageResult>;
+    /** The session's goal. 404s when the session never had one. */
+    getGoal(workspaceId: string, sessionId: string): Promise<SessionGoal>;
+    updateGoal(workspaceId: string, sessionId: string, request: UpdateSessionGoalRequest): Promise<SessionGoal>;
+    /** Pause the goal loop: the session stops self-continuing until resumed. */
+    pauseGoal(workspaceId: string, sessionId: string, options?: {
+        rationale?: string;
+    }): Promise<SessionGoal>;
+    /** Resume a paused goal: resets counters and re-arms the continuation loop. */
+    resumeGoal(workspaceId: string, sessionId: string): Promise<SessionGoal>;
+    /**
+     * Clear the session's conversation context. Destructive and audit-preserving:
+     * the server supersedes (never deletes) the live history and emits a
+     * `session.context.cleared` event. Refused (409) while a turn is in flight or
+     * awaiting action. `confirm:true` is sent so an accidental call cannot wipe
+     * context — the destructive intent is explicit on the wire.
+     */
+    clearSessionContext(workspaceId: string, sessionId: string): Promise<void>;
+    /**
+     * Trigger conversation compaction now. On the client-managed (Azure) path this
+     * queues a forced compaction the worker honors before the next turn
+     * (`status:"queued"`); on a server-managed provider or when compaction is off
+     * it is a no-op (`status:"noop"`) with an explanatory message.
+     */
+    compactSessionContext(workspaceId: string, sessionId: string): Promise<CompactSessionContextResult>;
+    /** The caller's access context: subject, account + workspace grants, defaults. */
+    getAccessContext(): Promise<AccessContext>;
+    listWorkspaces(): Promise<Workspace[]>;
+    createWorkspace(request: CreateWorkspaceRequest): Promise<Workspace>;
+    getWorkspace(workspaceId: string): Promise<Workspace>;
+    updateWorkspace(workspaceId: string, request: UpdateWorkspaceRequest): Promise<Workspace>;
+    createScheduledTask(workspaceId: string, request: CreateScheduledTaskRequest): Promise<ScheduledTask>;
+    updateScheduledTask(workspaceId: string, taskId: string, request: UpdateScheduledTaskRequest): Promise<ScheduledTask>;
+    pauseScheduledTask(workspaceId: string, taskId: string): Promise<ScheduledTask>;
+    resumeScheduledTask(workspaceId: string, taskId: string): Promise<ScheduledTask>;
+    /**
+     * Fire the task immediately (manual trigger), independent of its schedule.
+     * Pass a stable `triggerId` to make a retried trigger idempotent — the same
+     * token charges once and starts one run. Omit it and each call is distinct.
+     */
+    triggerScheduledTask(workspaceId: string, taskId: string, options?: {
+        triggerId?: string;
+    }): Promise<ScheduledTask>;
+    deleteScheduledTask(workspaceId: string, taskId: string): Promise<void>;
+    listScheduledTaskRuns(workspaceId: string, taskId: string, options?: {
+        limit?: number;
+    }): Promise<ScheduledTaskRun[]>;
+    listEnvironments(workspaceId: string): Promise<WorkspaceEnvironment[]>;
+    createEnvironment(workspaceId: string, request: CreateWorkspaceEnvironmentRequest): Promise<WorkspaceEnvironment>;
+    getEnvironment(workspaceId: string, environmentId: string): Promise<WorkspaceEnvironment>;
+    updateEnvironment(workspaceId: string, environmentId: string, request: UpdateWorkspaceEnvironmentRequest): Promise<WorkspaceEnvironment>;
+    deleteEnvironment(workspaceId: string, environmentId: string): Promise<void>;
+    /** Create or rotate a variable. The value never comes back on any read. */
+    setEnvironmentVariable(workspaceId: string, environmentId: string, name: string, value: string): Promise<WorkspaceEnvironmentVariableMetadata>;
+    deleteEnvironmentVariable(workspaceId: string, environmentId: string, name: string): Promise<void>;
+    /** Step 1 of the upload flow: returns the pre-signed PUT target. */
+    beginFileUpload(workspaceId: string, request: CreateFileUploadRequest): Promise<CreateFileUploadResponse>;
+    /** Step 3 of the upload flow: server verifies the object and marks it ready. */
+    completeFileUpload(workspaceId: string, uploadId: string): Promise<FileAsset>;
+    /**
+     * The whole upload flow as one call: begin -> PUT the bytes to the signed
+     * URL (with its required headers; no API auth is sent to object storage)
+     * -> complete. Returns the ready `FileAsset`.
+     */
+    uploadFile(workspaceId: string, input: UploadFileInput): Promise<FileAsset>;
+    getFile(workspaceId: string, fileId: string): Promise<FileAsset>;
+    /** Mint a short-lived signed download URL for a ready file. */
+    createFileDownloadUrl(workspaceId: string, fileId: string): Promise<FileDownloadUrlResponse>;
+    createDocumentBase(workspaceId: string, request: CreateDocumentBaseRequest): Promise<DocumentBase>;
+    listDocumentBases(workspaceId: string): Promise<DocumentBase[]>;
+    getDocumentBase(workspaceId: string, baseId: string): Promise<DocumentBase>;
+    /** Index an uploaded file into the base. The file must be `ready`. */
+    addDocument(workspaceId: string, baseId: string, request: {
+        fileId: string;
+    }): Promise<Document>;
+    listDocuments(workspaceId: string, baseId: string): Promise<Document[]>;
+    /** Retry indexing for a failed document. */
+    reindexDocument(workspaceId: string, baseId: string, documentId: string): Promise<Document>;
+    searchDocuments(workspaceId: string, baseId: string, request: {
+        query: string;
+        limit?: number;
+    }): Promise<DocumentSearchResponse>;
+    /** Built-in + registered packs, with the workspace's installations. */
+    listPacks(workspaceId: string): Promise<ListPacksResponse>;
+    /** Register (or replace) a workspace-scoped pack from a manifest. */
+    registerPack(workspaceId: string, manifest: RegisterCapabilityPackRequest): Promise<WorkspaceRegisteredPack>;
+    getPack(workspaceId: string, packId: string): Promise<GetPackResponse>;
+    enablePack(workspaceId: string, packId: string, request?: EnablePackRequest): Promise<PackInstallation>;
+    /** Unregister a workspace-scoped pack (built-in packs cannot be deleted). */
+    deletePack(workspaceId: string, packId: string): Promise<void>;
+    listPackInstallations(workspaceId: string): Promise<PackInstallation[]>;
+    listCapabilities(workspaceId: string): Promise<CapabilityCatalogResponse>;
+    /** Add a manual capability catalog item (e.g. a remote MCP server). */
+    createCapability(workspaceId: string, request: CreateCapabilityCatalogItemRequest): Promise<CapabilityCatalogItem>;
+    enableCapability(workspaceId: string, capabilityId: string, request?: EnableCapabilityRequest): Promise<CapabilityInstallation>;
+    disableCapability(workspaceId: string, capabilityId: string): Promise<CapabilityInstallation>;
+    /** Search the official MCP registry for installable capabilities. */
+    discoverMcpCapabilities(workspaceId: string, options?: {
+        query?: string;
+        limit?: number;
+    }): Promise<DiscoverMcpCapabilitiesResponse>;
+    /** GitHub App configuration status + a signed install URL when configured. */
+    getGitHubApp(workspaceId: string): Promise<GitHubAppInfo>;
+    /**
+     * Browser entry point that plants the CSRF cookie and forwards to GitHub's
+     * install page. Open this in a browser (it redirects); `state` comes from
+     * `getGitHubApp().installUrl` or a github_connect_link tool.
+     */
+    githubConnectUrl(workspaceId: string, state: string): string;
+    listGitHubRepositories(workspaceId: string): Promise<GitHubRepositoriesResponse>;
+    /** Re-sync the installation's repository list from GitHub. */
+    syncGitHubRepositories(workspaceId: string): Promise<GitHubRepositoriesResponse>;
+    /** Build a GitHub App manifest + the GitHub URL to submit it to. */
+    createGitHubAppManifest(workspaceId: string, request?: CreateGitHubAppManifestRequest): Promise<CreateGitHubAppManifestResponse>;
+    listApiKeys(workspaceId: string): Promise<ApiKey[]>;
+    /** The returned `token` is shown once; only its prefix is stored. */
+    createApiKey(workspaceId: string, request: CreateApiKeyRequest): Promise<CreateApiKeyResponse>;
+    /** Revoke an API key. Returns the revoked key. */
+    deleteApiKey(workspaceId: string, apiKeyId: string): Promise<ApiKey>;
+    getBilling(options?: {
+        accountId?: string;
+    }): Promise<BillingSummary>;
+    getBillingUsage(options?: {
+        accountId?: string;
+        workspaceId?: string;
+    }): Promise<BillingUsageResponse>;
+    getBillingEntitlements(options?: {
+        accountId?: string;
+    }): Promise<BillingEntitlementsResponse>;
+    /** Start a Stripe checkout for prepaid credits. */
+    createBillingCheckout(request: CreateCheckoutRequest): Promise<CreateCheckoutResponse>;
+    private headers;
+    private url;
+    private requestJson;
+    /** Like `requestJson` for endpoints that respond with no body (204). */
+    private requestVoid;
+}
+
+/** Error for a non-2xx OpenGeni API response. */
+declare class OpenGeniApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string);
+}
+/** Error for an unrecoverable event-stream condition (not a transient drop). */
+declare class OpenGeniStreamError extends Error {
+    constructor(message: string);
+}
+/**
+ * Transient conditions worth a reconnect: network-level failures (`fetch`
+ * rejects with `TypeError`) and HTTP statuses that signal a temporary server
+ * or contention condition. Auth/validation failures (401/403/404/...) are
+ * permanent and surface to the caller instead.
+ */
+declare function isRetryableStreamError(error: unknown): boolean;
+
+/**
+ * Proxy-through-your-own-API helpers.
+ *
+ * The intended pattern: a customer's server consumes the OpenGeni event
+ * stream with its own API key (`client.streamEvents(...)`) and re-emits it to
+ * its browser clients over its own authenticated endpoint — the OpenGeni key
+ * never reaches the browser. The re-emitted wire format is identical to
+ * OpenGeni's own SSE stream (`id: <sequence>`, `event: <type>`,
+ * `data: <event JSON>`), so the browser side can consume it with this same
+ * SDK's streaming core (or a plain `EventSource`), including resume via
+ * `?after=` / `Last-Event-ID`.
+ */
+/** Format one event exactly as OpenGeni's API emits it over SSE. */
+declare function formatSseEvent(event: SessionEvent): string;
+type SseReStreamOptions = {
+    /**
+     * Emit `: ping` comment lines at this interval, keeping intermediaries from
+     * idling the connection out. Disabled when omitted.
+     */
+    heartbeatMs?: number;
+    /**
+     * Called when the downstream consumer cancels (e.g. the browser
+     * disconnected). Use it to abort the upstream OpenGeni stream — an async
+     * iterator that is mid-`await` cannot be interrupted by `return()` alone.
+     */
+    onCancel?: () => void;
+};
+/**
+ * Re-emit a stream of session events as an SSE byte stream. Pull-based, so
+ * upstream consumption follows downstream demand; cancelling the returned
+ * stream fires `onCancel` and ends the upstream iterator.
+ */
+declare function sessionEventsToSseStream(events: AsyncIterable<SessionEvent>, options?: SseReStreamOptions): ReadableStream<Uint8Array>;
+/** Wrap an event stream in a ready-to-return SSE `Response`. */
+declare function sessionEventsToSseResponse(events: AsyncIterable<SessionEvent>, options?: SseReStreamOptions): Response;
+/**
+ * Read the resume cursor a reconnecting SSE client sent: the `after` query
+ * parameter, or the standard `Last-Event-ID` header (the re-emitted stream
+ * sets `id:` to the sequence). Returns 0 (full replay) when absent.
+ */
+declare function resumeSequenceFromRequest(request: Request): number;
+type ProxySessionEventStreamOptions = Omit<StreamSessionEventsOptions, "after"> & {
+    /**
+     * Resume cursor. Pass a number, or the incoming browser `Request` to
+     * honor its `?after=` / `Last-Event-ID` automatically.
+     */
+    after?: number | Request;
+    /** See {@link SseReStreamOptions.heartbeatMs}. */
+    heartbeatMs?: number;
+};
+/**
+ * One-call proxy: consume the OpenGeni stream server-side and return an SSE
+ * `Response` for your own browser clients. Works anywhere WHATWG `Response`
+ * is the handler return type (Hono, Next.js route handlers, Bun.serve,
+ * Cloudflare Workers, ...).
+ *
+ * The upstream OpenGeni connection is torn down when the downstream client
+ * disconnects, and also when `options.signal` (e.g. the incoming request's
+ * signal) aborts.
+ */
+declare function proxySessionEventStream(client: OpenGeniClient, workspaceId: string, sessionId: string, options?: ProxySessionEventStreamOptions): Response;
+
+/**
+ * Minimal incremental Server-Sent Events parser over a byte stream.
+ *
+ * Implements the parts of the SSE wire format OpenGeni uses: `id`, `event`,
+ * and `data` fields, multi-line data, comment lines, and both LF and CRLF
+ * line endings. Messages without any `data` (comments, id-only blocks) are
+ * not emitted.
+ */
+type SseMessage = {
+    id?: string;
+    event?: string;
+    data: string;
+};
+declare function parseSseStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseMessage, void, void>;
+
+export { type AccessContext, type AccessGrant, type AccountGrant, type AccountRole, type AgentMessageCompletedPayload, type AgentTextDeltaPayload, type AgentToolCallCreatedPayload, type AgentToolCallOutputPayload, type ApiKey, type BillingBalance, type BillingEntitlementsResponse, type BillingMode, type BillingSummary, type BillingUsageResponse, type CapabilityCatalogItem, type CapabilityCatalogResponse, type CapabilityInstallation, type CapabilityInstallationStatus, type CapabilityKind, type CapabilityPack, type CapabilityPackConnector, type CapabilityPackConnectorAuthModel, type CapabilityPackEnvironmentSpec, type CapabilityPackKnowledge, type CapabilityPackScheduledTaskTemplate, type CapabilityPackSkill, type CapabilityPackSkillFile, type CapabilityRuntime, type CapabilitySource, type ClientSessionEventInput, type CompactSessionContextResult, type CompleteFileUploadResponse, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateCapabilityCatalogItemRequest, type CreateCheckoutRequest, type CreateCheckoutResponse, type CreateDocumentBaseRequest, type CreateFileUploadRequest, type CreateFileUploadResponse, type CreateGitHubAppManifestRequest, type CreateGitHubAppManifestResponse, type CreateScheduledTaskRequest, type CreateSessionRequest, type CreateWorkspaceEnvironmentRequest, type CreateWorkspaceRequest, type DiscoverMcpCapabilitiesResponse, type Document, type DocumentBase, type DocumentSearchRequest, type DocumentSearchResponse, type DocumentSearchResult, type DocumentStatus, type EnableCapabilityRequest, type EnablePackRequest, type EntitlementValue, type Entitlements, type EntitlementsMode, type FetchLike, type FileAsset, type FileDownloadUrlResponse, type FileResourceRef, type FileStatus, type FileUploadData, type GetPackResponse, type GitHubAppInfo, type GitHubRepositoriesResponse, type GitHubRepository, type GoalSpec, KNOWN_PERMISSIONS, KNOWN_USAGE_EVENT_TYPES, type KnownPermission, type KnownSessionEventType, type KnownUsageEventType, type ListApiKeysResponse, type ListPacksResponse, OpenGeniApiError, OpenGeniClient, type OpenGeniClientOptions, OpenGeniStreamError, type PackInstallation, type PackInstallationStatus, type Permission, type ProductAccessMode, type ProxySessionEventStreamOptions, type ReasoningEffort, type RegisterCapabilityPackRequest, type RepositoryResourceRef, type ResourceRef, SESSION_EVENT_TYPES, type SandboxBackend, type ScheduledTask, type ScheduledTaskAgentConfig, type ScheduledTaskAgentConfigInput, type ScheduledTaskDayOfWeek, type ScheduledTaskOverlapPolicy, type ScheduledTaskRun, type ScheduledTaskRunMode, type ScheduledTaskRunStatus, type ScheduledTaskScheduleSpec, type ScheduledTaskStatus, type ScheduledTaskTriggerType, type SendMessageInput, type Session, type SessionEvent, type SessionEventStreamTransport, type SessionEventType, type SessionGoal, type SessionGoalCreatedBy, type SessionGoalStatus, type SessionStatus, type SessionStatusChangedPayload, type SessionTurn, type SessionTurnSource, type SessionTurnStatus, type SseMessage, type SseReStreamOptions, type SteerMessageResult, type StreamConnectionState, type StreamSessionEventsOptions, type ToolRef, type UpdateScheduledTaskRequest, type UpdateSessionGoalRequest, type UpdateSessionTurnRequest, type UpdateWorkspaceEnvironmentRequest, type UpdateWorkspaceRequest, type UploadFileInput, type UsageEvent, type UsageEventType, type UserApprovalDecisionEventInput, type UserInterruptEventInput, type UserMessageEventInput, type Workspace, type WorkspaceEnvironment, type WorkspaceEnvironmentVariableMetadata, type WorkspaceRegisteredPack, formatSseEvent, isRetryableStreamError, parseSseStream, proxySessionEventStream, resumeSequenceFromRequest, sessionEventsToSseResponse, sessionEventsToSseStream, streamSessionEvents };