@kortix/sdk 0.9.98

package/dist/kortix.d.ts

@@ -0,0 +1,897 @@
+import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+/**
+ * createKortix — the single opinionated entry point to the Kortix data layer.
+ *
+ * One client. Every action a method. The host app imports ONLY from `@kortix/sdk`
+ * — never `@opencode-ai/sdk`, never `backendApi`/`authenticatedFetch` directly.
+ *
+ *   const kortix = createKortix({ getToken });
+ *   await kortix.projects.list();
+ *   await kortix.project(pid).secrets.upsert({ name, value });
+ *   const s = kortix.session(pid, sid);
+ *   await s.start();
+ *   s.runtime.session.prompt({ sessionID: sid, parts });   // typed opencode, via the SDK
+ *
+ * REST methods are direct references to the platform client, so they keep their
+ * exact types with zero re-typing. The `project()`/`session()` handles bind ids
+ * for ergonomics. Reactive data still comes from `@kortix/sdk/react` hooks.
+ */
+import * as F from './files/client.js';
+import { type KortixPlatformConfig } from './platform/config.js';
+import * as P from './platform/projects-client/index.js';
+import { type SessionRuntimeEntry } from './state/session-runtime-registry.js';
+import { type EventStreamHandle, type OpenCodeEvent } from './state/event-stream.js';
+/** A model the agent can run, as the opencode runtime identifies it. */
+export type SessionModel = {
+    providerID: string;
+    modelID: string;
+};
+/** The opencode runtime client for the currently-active sandbox (set by the host). */
+declare function runtime(): OpencodeClient;
+export declare class SessionNotReadyError extends Error {
+    constructor(action: string);
+}
+export declare function createKortix(config: KortixPlatformConfig, opts?: {
+    global?: boolean;
+}): {
+    /** The platform config in effect (for diagnostics). */
+    config: KortixPlatformConfig;
+    accounts: {
+        list: typeof P.listAccounts;
+        get: typeof P.getAccount;
+        create: typeof P.createAccount;
+        updateName: typeof P.updateAccountName;
+        leave: typeof P.leaveAccount;
+        members: typeof P.listAccountMembers;
+        invite: typeof P.inviteAccountMember;
+        removeMember: typeof P.removeAccountMember;
+        updateMemberRole: typeof P.updateAccountMemberRole;
+        invites: typeof P.listAccountInvites;
+        /** Cancel a pending account invite (accountId still known/scoped). */
+        cancelInvite: typeof P.cancelAccountInvite;
+        /** Resend a pending account invite (accountId still known/scoped). */
+        resendInvite: typeof P.resendAccountInvite;
+        /** CLI PAT minting — account-scoped personal access tokens (`kortix_pat_...`). */
+        tokens: {
+            list: typeof P.listAccountTokens;
+            create: typeof P.createAccountToken;
+            revoke: typeof P.revokeAccountToken;
+        };
+        /** Enterprise audit log — events + CSV/JSONL export + SIEM webhooks. */
+        audit: {
+            log: typeof P.listAccountAudit;
+            export: typeof P.exportAccountAudit;
+            webhooks: {
+                list: typeof P.listAccountAuditWebhooks;
+                create: typeof P.createAccountAuditWebhook;
+                update: typeof P.updateAccountAuditWebhook;
+                remove: typeof P.removeAccountAuditWebhook;
+            };
+        };
+    };
+    /** Account-invite lifecycle reached by invite token alone (accept/decline/describe). */
+    accountInvites: {
+        describe: typeof P.describeAccountInvite;
+        accept: typeof P.acceptAccountInvite;
+        decline: typeof P.declineAccountInvite;
+    };
+    projects: {
+        list: typeof P.listProjects;
+        listForAccount: typeof P.listProjectsForAccount;
+        get: typeof P.getProject;
+        detail: typeof P.getProjectDetail;
+        create: typeof P.createProject;
+        /** Create a project backed by a brand-new Kortix-managed GitHub repo. */
+        createRepo: typeof P.createProjectRepo;
+        provision: typeof P.provisionProject;
+        update: typeof P.updateProject;
+        archive: typeof P.archiveProject;
+        llmCatalog: typeof P.getProjectLlmCatalog;
+        sandboxHealth: typeof P.getProjectSandboxHealth;
+        sandboxTemplates: typeof P.listProjectSandboxTemplates;
+        sessions: typeof P.listProjectSessions;
+        createSession: typeof P.createProjectSession;
+    };
+    project: (projectId: string) => {
+        get: (opts?: Parameters<typeof P.getProject>[1]) => Promise<P.KortixProject>;
+        detail: () => Promise<P.ProjectDetail>;
+        update: (input: Parameters<typeof P.updateProject>[1]) => Promise<P.KortixProject>;
+        archive: () => Promise<{
+            ok: boolean;
+        }>;
+        llmCatalog: () => Promise<P.ProjectLlmCatalogResponse>;
+        sandboxHealth: () => Promise<P.ProjectSandboxHealth>;
+        onboardingComplete: (completed: boolean) => Promise<P.KortixProject>;
+        /** Project-scoped CLI PATs (auto-minted at session-create as `KORTIX_TOKEN`; can also be minted by hand). */
+        tokens: {
+            list: () => Promise<P.ProjectCliTokenListResponse>;
+            create: (input?: Parameters<typeof P.createProjectCliToken>[1]) => Promise<P.CreatedProjectCliToken>;
+            revoke: (tokenId: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        /** Agent-minted setup links — hand a human a link to enter a secret value or 1-click connect an app. */
+        setupLinks: {
+            requestSecret: (input: Parameters<typeof P.requestProjectSecret>[1]) => Promise<P.SecretRequestLink>;
+            requestConnector: (input: Parameters<typeof P.requestProjectConnector>[1]) => Promise<P.ConnectorRequestLink>;
+        };
+        /** Validate a `kortix.toml` manifest's raw TOML text server-side (same schema `kortix ship`/CR-merge use). */
+        validateManifest: (raw: string) => Promise<P.ManifestValidationResult>;
+        /** Mint a fresh scoped git push token for a managed project (409 for BYO repos). */
+        gitToken: () => Promise<P.ProjectGitToken>;
+        /** Marketplace install/updates — commits an item's files (+ lock) straight onto the default branch. */
+        marketplace: {
+            list: () => Promise<P.MarketplaceInstalledResponse>;
+            install: (id: string) => Promise<P.MarketplaceInstallResult>;
+            updates: () => Promise<P.MarketplaceUpdatesResponse>;
+            update: (name: string) => Promise<P.MarketplaceUpdateResult>;
+            updateAll: () => Promise<P.MarketplaceUpdateAllResult>;
+            remove: (name: string) => Promise<P.MarketplaceRemoveResult>;
+        };
+        /** `registry.*` — compatibility alias of `marketplace.*` (identical server-side handlers). */
+        registry: {
+            list: () => Promise<P.MarketplaceInstalledResponse>;
+            install: (id: string) => Promise<P.MarketplaceInstallResult>;
+            updates: () => Promise<P.MarketplaceUpdatesResponse>;
+            update: (name: string) => Promise<P.MarketplaceUpdateResult>;
+            updateAll: () => Promise<P.MarketplaceUpdateAllResult>;
+            remove: (name: string) => Promise<P.MarketplaceRemoveResult>;
+        };
+        secrets: {
+            list: () => Promise<P.ProjectSecretsResponse>;
+            upsert: (input: Parameters<typeof P.upsertProjectSecret>[1]) => Promise<P.ProjectSecret>;
+            remove: (name: string) => Promise<{
+                ok: boolean;
+            }>;
+            setPersonal: (name: string, input: {
+                value?: string;
+                active?: boolean;
+            }) => Promise<P.ProjectSecret>;
+            removePersonal: (name: string) => Promise<{
+                ok: boolean;
+            }>;
+            setGitCredential: (input: Parameters<typeof P.upsertProjectGitCredential>[1]) => Promise<{
+                configured: boolean;
+                provider: string;
+                git_connection: P.ProjectGitConnection;
+            }>;
+            /** Device-code OAuth flow to connect a subscription-backed provider (e.g. ChatGPT). */
+            startProviderOAuth: (provider: string, input?: {
+                sharing?: P.ConnectorSharing;
+            } | undefined) => Promise<P.ProviderOAuthStart>;
+            pollProviderOAuth: (provider: string, flowId: string) => Promise<P.ProviderOAuthPoll>;
+        };
+        access: {
+            list: () => Promise<P.ProjectAccessResponse>;
+            invite: (email: string, role: P.ProjectRole) => Promise<P.ProjectAccessMember | {
+                status: "invited";
+                email: string;
+                invite_id: string;
+                project_role: P.ProjectRole;
+                message: string;
+                invite_url: string;
+                email_sent: boolean;
+                email_skip_reason: string | null;
+            }>;
+            update: (userId: string, role: P.ProjectRole) => Promise<P.ProjectAccessMember>;
+            revoke: (userId: string) => Promise<{
+                ok: boolean;
+            }>;
+            pendingInvites: () => Promise<{
+                pending: P.PendingProjectInvite[];
+            }>;
+            resendInvite: (inviteId: string) => Promise<P.ResendProjectInviteResult>;
+            revokeInvite: (inviteId: string) => Promise<{
+                ok: boolean;
+                invitation_cancelled: boolean;
+            }>;
+            requests: () => Promise<{
+                requests: P.ProjectAccessRequest[];
+            }>;
+            approveRequest: (requestId: string, role?: P.ProjectRole | undefined) => Promise<{
+                request: P.ProjectAccessRequest;
+                member: P.ProjectAccessMember;
+            }>;
+            rejectRequest: (requestId: string) => Promise<{
+                request: P.ProjectAccessRequest;
+            }>;
+            groupGrants: () => Promise<{
+                grants: P.ProjectGroupGrant[];
+            }>;
+            attachGroupGrant: (groupId: string, role: P.ProjectRole, expiresAt?: string | null | undefined) => Promise<{
+                project_id: string;
+                group_id: string;
+                role: P.ProjectRole;
+            }>;
+            updateGroupGrant: (groupId: string, role: P.ProjectRole, expiresAt?: string | null | undefined) => Promise<{
+                project_id: string;
+                group_id: string;
+                role: P.ProjectRole;
+            }>;
+            detachGroupGrant: (groupId: string) => Promise<{
+                ok: boolean;
+            }>;
+            /** Per-resource (agent/skill/secret) grants to a member or a group. */
+            resourceGrants: {
+                list: () => Promise<P.ProjectResourceGrantsResponse>;
+                create: (input: Parameters<typeof P.createProjectResourceGrant>[1]) => Promise<{
+                    grant_id: string;
+                }>;
+                remove: (grantId: string) => Promise<{
+                    ok: boolean;
+                }>;
+            };
+        };
+        connectors: {
+            list: () => Promise<P.ConnectorsResponse>;
+            config: (slug: string) => Promise<P.ConnectorConfig>;
+            create: (draft: P.ConnectorDraftInput) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            remove: (slug: string) => Promise<{
+                ok: boolean;
+            }>;
+            sync: () => Promise<P.ConnectorSyncResult>;
+            setName: (slug: string, name: string) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            setCredentialMode: (slug: string, mode: "shared") => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            setCredential: (slug: string, value: string) => Promise<{
+                ok: boolean;
+            }>;
+            setSensitive: (slug: string, sensitive: boolean) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            policies: {
+                get: (slug: string) => Promise<{
+                    policies: P.ConnectorPolicyRule[];
+                }>;
+                set: (slug: string, policies: P.ConnectorPolicyRule[]) => Promise<{
+                    ok: boolean;
+                    sync?: P.ConnectorSyncResult;
+                }>;
+            };
+            /** Easy-connect (Pipedream): app catalog + connect/finalize handshake. */
+            pipedream: {
+                listApps: (q?: string | undefined, cursor?: string | undefined) => Promise<{
+                    apps: P.PipedreamApp[];
+                    nextCursor?: string;
+                    hasMore: boolean;
+                }>;
+                connect: (slug: string) => Promise<{
+                    token?: string;
+                    app?: string;
+                    connectUrl?: string;
+                }>;
+                finalize: (slug: string) => Promise<{
+                    connected: boolean;
+                    accountId?: string;
+                }>;
+            };
+        };
+        policies: {
+            list: () => Promise<P.ProjectPoliciesResponse>;
+            set: (policies: P.ProjectPolicy[], defaultMode: P.PolicyDefaultMode) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+        };
+        triggers: {
+            list: () => Promise<P.ProjectTriggerListing>;
+            create: (input: P.CreateProjectTriggerInput) => Promise<P.ProjectTriggerListing>;
+            update: (slug: string, input: P.UpdateProjectTriggerInput) => Promise<P.ProjectTriggerListing>;
+            remove: (slug: string) => Promise<{
+                ok: boolean;
+            }>;
+            fire: (slug: string) => Promise<P.FireProjectTriggerResponse>;
+            setActivation: (paused: boolean) => Promise<P.ProjectTriggerListing>;
+        };
+        files: {
+            list: (options?: Parameters<typeof P.listProjectFiles>[1]) => Promise<P.ProjectFileEntry[]>;
+            read: (path: string, ref?: string) => Promise<{
+                path: string;
+                ref: string;
+                content: string;
+            }>;
+            search: (query: string, options?: {
+                content?: boolean;
+                ref?: string;
+                limit?: number;
+            } | undefined) => Promise<P.ProjectFileSearchResponse>;
+            archive: (ref: string, path?: string | undefined) => Promise<Blob>;
+            history: (path: string, options?: {
+                ref?: string;
+                limit?: number;
+                skip?: number;
+            } | undefined) => Promise<P.ProjectFileHistoryResponse>;
+        };
+        git: {
+            commits: () => Promise<P.ProjectCommitsResponse>;
+            commit: (sha: string) => Promise<P.ProjectCommitDetail>;
+            commitDiff: (sha: string) => Promise<P.ProjectCommitDiffResponse>;
+            branches: () => Promise<P.ProjectBranchesResponse>;
+            versionDiff: (input: {
+                from: string;
+                into: string;
+            }) => Promise<P.VersionDiffPreview>;
+            /** Invite a GitHub user as a collaborator on a Kortix-managed repo. */
+            inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
+        };
+        changeRequests: {
+            list: () => Promise<{
+                change_requests: P.ChangeRequest[];
+            }>;
+            get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
+            diff: (crId: string) => Promise<P.ChangeRequestDiffResponse>;
+            mergePreview: (crId: string) => Promise<P.ChangeRequestMergePreview>;
+            open: (input: {
+                title: string;
+                description?: string;
+                head_ref: string;
+                base_ref?: string;
+                session_id?: string;
+            }) => Promise<P.ChangeRequest>;
+            merge: (crId: string, input?: {
+                message?: string;
+            } | undefined) => Promise<P.ChangeRequestMergeResponse>;
+            close: (crId: string) => Promise<P.ChangeRequest>;
+            reopen: (crId: string) => Promise<P.ChangeRequest>;
+            /** Request changes on a CR (Review Center) — records feedback + optionally delivers it back to the originating session. */
+            requestChanges: (crId: string, feedback: string) => Promise<{
+                change_request: P.ChangeRequest;
+                delivering: boolean;
+            }>;
+        };
+        sessions: {
+            list: () => Promise<P.ProjectSession[]>;
+            create: (input?: Parameters<typeof P.createProjectSession>[1]) => Promise<P.ProjectSession>;
+        };
+        /** Review Center — the per-project human-in-the-loop inbox (change requests, tool approvals, agent outputs/decisions). */
+        review: {
+            list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
+                review_items: P.ApiReviewItem[];
+            }>;
+            get: (reviewItemId: string) => Promise<{
+                review_item: P.ApiReviewItem;
+            }>;
+            submit: (input: Parameters<typeof P.submitReviewItem>[1]) => Promise<P.ApiReviewItem>;
+            act: (reviewItemId: string, input: {
+                verdict: P.ReviewVerdict;
+                feedback?: string;
+            }) => Promise<P.ApiReviewItem>;
+            bulkAct: (input: Parameters<typeof P.bulkActReviewItems>[1]) => Promise<{
+                updated: number;
+                review_items: P.ApiReviewItem[];
+            }>;
+        };
+        /** The manager inbox of executor-gated actions awaiting approve/deny (APPROVE / ASK / BLOCK). */
+        approvals: {
+            list: (options?: Parameters<typeof P.listPendingApprovals>[1]) => Promise<P.PendingApprovalsResponse>;
+            resolve: (executionId: string, decision: "approve" | "deny", scope?: "session" | "once" | "session_all" | undefined) => Promise<{
+                ok: boolean;
+                scope?: "once" | "session" | "session_all";
+            }>;
+            sessionsNeedingInput: (options?: Parameters<typeof P.listSessionsNeedingInput>[1]) => Promise<P.SessionsNeedingInputResponse>;
+        };
+        /** Gateway observability — LLM request logs, cost/latency rollups, budgets, gateway API keys. */
+        gateway: {
+            logs: (opts?: Parameters<typeof P.listGatewayLogs>[1]) => Promise<P.GatewayLogsResponse>;
+            log: (logId: string) => Promise<P.GatewayLogDetail>;
+            overview: (days?: number) => Promise<P.GatewayOverview>;
+            series: (days?: number) => Promise<P.GatewaySeries>;
+            breakdown: (days?: number) => Promise<P.GatewayBreakdown>;
+            sessions: (days?: number) => Promise<P.GatewaySessions>;
+            errors: (days?: number) => Promise<P.GatewayErrorsResponse>;
+            budgets: () => Promise<P.GatewayBudgetsResponse>;
+            setBudget: (input: Parameters<typeof P.setGatewayBudget>[1]) => Promise<{
+                ok: boolean;
+            }>;
+            deleteBudget: (budgetId: string) => Promise<{
+                ok: boolean;
+            }>;
+            keys: () => Promise<{
+                keys: P.GatewayKeyRow[];
+                gateway_url?: string | null;
+            }>;
+            createKey: (name: string) => Promise<P.CreatedGatewayKey>;
+            revokeKey: (keyId: string) => Promise<{
+                ok: boolean;
+            }>;
+            /** Run one prompt against up to 6 models side by side (a model-comparison playground). */
+            playground: (prompt: string, models: string[]) => Promise<P.GatewayPlaygroundResponse>;
+        };
+        /** Slack + email + Meet channel integrations. */
+        channels: {
+            slack: {
+                installation: () => Promise<P.SlackInstallation | null>;
+                connect: (input: Parameters<typeof P.connectSlack>[1]) => Promise<P.SlackInstallation>;
+                mode: () => Promise<P.SlackMode>;
+                manifest: () => Promise<Record<string, unknown>>;
+                disconnect: () => Promise<void>;
+                /** Download a Slack-hosted file through the server-side proxy (bot token stays server-side). */
+                getFile: (url: string) => Promise<Blob>;
+                /** Upload a file to Slack through the server-side 3-step external-upload proxy. */
+                uploadFile: (input: Parameters<typeof P.uploadSlackChannelFile>[1]) => Promise<P.UploadSlackChannelFileResult>;
+            };
+            email: {
+                installation: (connectorSlug?: string | null) => Promise<P.EmailInstallation | null>;
+                mode: () => Promise<P.EmailMode>;
+                connect: (input: Parameters<typeof P.connectEmail>[1]) => Promise<P.EmailInstallation>;
+                disconnect: (connectorSlug?: string | null) => Promise<void>;
+                updatePolicy: (connectorSlug: string | null | undefined, senderPolicy: P.EmailSenderPolicy) => Promise<P.EmailInstallation>;
+            };
+            meet: {
+                voices: () => Promise<P.MeetVoicesResponse | null>;
+                setVoice: (voice: string) => Promise<{
+                    selected: string;
+                }>;
+                setBotName: (name: string) => Promise<{
+                    bot_name: string;
+                }>;
+                previewVoice: (voiceId: string) => Promise<string | null>;
+                /** Make the meeting bot speak text (text → ElevenLabs → Recall `output_audio`). */
+                speak: (botId: string, text: string, voice?: string) => Promise<P.SpeakInMeetingResult>;
+            };
+        };
+        /** Project apps/deployments — the `/projects/:id/apps/*` family. */
+        apps: {
+            list: () => Promise<P.ListProjectAppsResponse>;
+            create: (input: Parameters<typeof P.createProjectApp>[1]) => Promise<P.ListProjectAppsResponse>;
+            update: (slug: string, input: Partial<P.CreateOrUpdateProjectAppInput>) => Promise<P.ListProjectAppsResponse>;
+            remove: (slug: string) => Promise<P.ListProjectAppsResponse>;
+            deploy: (slug: string) => Promise<P.DeployProjectAppResponse>;
+            stop: (slug: string) => Promise<P.StopProjectAppResponse>;
+            logs: (slug: string) => Promise<P.ProjectAppLogsResponse>;
+            /** @deprecated Use `updateExperimentalFeature('apps', enabled)` — kept for parity with the underlying client. */
+            updateConfig: (input: Parameters<typeof P.updateAppsConfig>[1]) => Promise<P.KortixProject>;
+        };
+        /** Toggle an experimental feature (Customize → Settings → Experimental). Pass `enabled: null` to clear the override. */
+        updateExperimentalFeature: (feature: P.ExperimentalFeatureKey, enabled: boolean | null) => Promise<P.KortixProject>;
+        /** Default model preferences (account/agent/project scope, gateway-resolved). */
+        modelDefaults: {
+            get: () => Promise<P.ModelDefaultsResponse>;
+            set: (input: Parameters<typeof P.setModelDefault>[1]) => Promise<{
+                ok: boolean;
+                scope: string;
+                agentName?: string;
+                model: string;
+            }>;
+            clear: (params: Parameters<typeof P.clearModelDefault>[1]) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        /** Sandbox templates + snapshot builds — Dockerfile/image/warm-pool config, beyond `sandboxHealth`/`sandboxTemplates`. */
+        sandbox: {
+            list: () => Promise<P.SandboxTemplatesResponse>;
+            snapshots: () => Promise<P.ProjectSnapshotsResponse>;
+            rebuildSnapshot: (slug?: string) => Promise<P.RebuildSnapshotResponse>;
+            fixWithAgent: () => Promise<{
+                session_id: string;
+            }>;
+            createTemplate: (input: Parameters<typeof P.createSandboxTemplate>[1]) => Promise<{
+                template_id: string;
+                slug: string;
+            }>;
+            updateTemplate: (templateId: string, input: P.UpdateSandboxTemplateInput) => Promise<{
+                template_id: string;
+                slug: string;
+            }>;
+            removeTemplate: (templateId: string) => Promise<null>;
+            buildTemplate: (templateId: string) => Promise<{
+                status: "started";
+                template_id: string;
+                slug: string;
+            }>;
+            /** Pin/clear the per-project sandbox provider (null = follow the platform default). */
+            setProvider: (provider: string | null) => Promise<P.KortixProject>;
+        };
+        /** Bind specific secrets + connectors to an agent (the inheritance pyramid's declaration step). */
+        setAgentScope: (agentName: string, scope: {
+            env?: P.AgentGrantSet;
+            connectors?: P.AgentGrantSet;
+        }) => Promise<{
+            ok: boolean;
+            agent: string;
+            env: P.AgentGrantSet;
+            connectors: P.AgentGrantSet;
+        }>;
+        session: (sessionId: string) => {
+            get: (opts?: {
+                showErrors?: boolean;
+            }) => Promise<P.ProjectSession>;
+            update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
+            delete: () => Promise<{
+                ok: boolean;
+            }>;
+            start: (waitMs?: number | undefined) => Promise<P.SessionStartResult | null>;
+            restart: () => Promise<{
+                ok: boolean;
+                session_id: string;
+                status: string;
+            }>;
+            stop: () => Promise<{
+                ok: boolean;
+                session_id: string;
+                status: string;
+            }>;
+            setSharing: (intent: Parameters<typeof P.setProjectSessionSharing>[2]) => Promise<P.ProjectSession>;
+            previews: () => Promise<{
+                candidates: P.SessionPreviewCandidate[];
+            }>;
+            commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
+            publicShares: {
+                list: () => Promise<{
+                    shares: P.SessionPublicShare[];
+                }>;
+                create: (input: P.CreateSessionPublicShareInput) => Promise<{
+                    share: P.SessionPublicShare;
+                }>;
+                revoke: (shareId: string) => Promise<{
+                    share: P.SessionPublicShare;
+                }>;
+            };
+            /** Per-session audit trail of executor-gated agent actions. */
+            audit: (limit?: number, options?: {
+                showErrors?: boolean;
+            }) => Promise<P.SessionAudit>;
+            /** Compact server-side transcript read (text + tool calls, no tool inputs/outputs) — callable with project-scoped session tokens. */
+            transcript: (options?: Parameters<typeof P.getSessionTranscript>[2]) => Promise<P.SessionTranscript>;
+            /**
+             * Resolve THIS handle's own runtime (idempotent): provisions/resumes the
+             * sandbox (long-poll until ready) and caches the resolved OpenCode session
+             * id + runtime URL + sandbox id for every other call on this handle. Call
+             * this (or `send`/`abort`, which call it internally) before `.runtime`,
+             * `.health()`, `.previewUrl()`, or `.proxyUrl()` — those throw
+             * `SessionNotReadyError` instead of falling back to whatever sandbox
+             * happens to be globally active.
+             */
+            ensureReady: () => Promise<SessionRuntimeEntry>;
+            /**
+             * Liveness/readiness of THIS session's runtime (`GET /kortix/health`).
+             * Unlike `.previewUrl()`/`.proxyUrl()`/`.runtime`, this never throws
+             * `SessionNotReadyError` — a health poller (e.g. a header dot ticking
+             * every 15s on a fresh inline handle) needs to be callable BEFORE the
+             * session has ever resolved a runtime. It degrades to the same graceful
+             * `{ status: 0, ok: false }` shape `getSessionHealth` already returns for
+             * "no URL yet", instead of forcing every caller to guard with `ensureReady()`.
+             */
+            health: (init?: RequestInit) => Promise<import("./index.js").SessionHealthResult>;
+            /** Proxy/preview URL for a port THIS session's runtime exposes. */
+            previewUrl: (port: number, path?: string) => string;
+            /** Rewrite a localhost URL the agent printed into a reachable proxy URL. */
+            proxyUrl: (url?: string) => string | undefined;
+            /** Pick the model `send` will use for subsequent prompts (until changed). */
+            setModel: (model: SessionModel | undefined) => void;
+            /** Pick the agent `send` will use for subsequent prompts (until changed). */
+            setAgent: (agent: string | undefined) => void;
+            /**
+             * Provision/resume if needed, then send a text prompt to the agent. A
+             * per-call `{ model, agent }` overrides the sticky setModel/setAgent
+             * choices for this message only.
+             */
+            send: (text: string, opts?: {
+                model?: SessionModel;
+                agent?: string;
+            }) => Promise<({
+                data: {
+                    info: import("@opencode-ai/sdk/v2/types").AssistantMessage;
+                    parts: Array<import("@opencode-ai/sdk/v2/types").Part>;
+                };
+                error: undefined;
+            } | {
+                data: undefined;
+                error: import("@opencode-ai/sdk/v2/types").EffectHttpApiErrorBadRequest | import("@opencode-ai/sdk/v2/types").InvalidRequestError | import("@opencode-ai/sdk/v2/types").NotFoundError;
+            }) & {
+                request: Request;
+                response: Response;
+            }>;
+            /** Abort the agent's current run in this session. */
+            abort: () => Promise<({
+                data: boolean;
+                error: undefined;
+            } | {
+                data: undefined;
+                error: import("@opencode-ai/sdk/v2/types").EffectHttpApiErrorBadRequest | import("@opencode-ai/sdk/v2/types").InvalidRequestError;
+            }) & {
+                request: Request;
+                response: Response;
+            }>;
+            /**
+             * Live SSE stream of THIS session's runtime events (message/part
+             * updates, session status, permissions/questions, lsp diagnostics, …).
+             * A thin facade over the framework-free `openEventStream` primitive
+             * (`@kortix/sdk`'s `openEventStream`, also used verbatim by
+             * `@kortix/sdk/react`'s `useOpenCodeEventStream`): resolves THIS
+             * handle's own runtime first (`ensureReady()`), then connects a client
+             * bound to that runtime URL — never the module-global "active" one, so
+             * two session handles on two different sandboxes never cross wires.
+             * Framework-free — safe to call from a server-side "Kortix as a
+             * Backend" wrapper (Node/Bun), a worker, a CLI, or any non-React host.
+             *
+             * Handles connect/reconnect/backoff, a 15s heartbeat watchdog, and
+             * event coalescing internally. Call `handle.close()` to stop.
+             *
+             *   const handle = await session.stream({ onEvent: (e) => console.log(e) });
+             *   // later
+             *   handle.close();
+             */
+            stream: (opts: {
+                onEvent: (event: OpenCodeEvent) => void;
+                onGapRehydrate?: (gapMs: number) => void;
+                signal?: AbortSignal;
+            }) => Promise<EventStreamHandle>;
+            readonly runtime: OpencodeClient;
+            /**
+             * Workspace file operations (daemon `/file` + `/find`) bound to THIS
+             * session's own resolved runtime — never the module-global "active"
+             * sandbox the top-level `@kortix/sdk` `files` export follows. Fixes a
+             * cross-session bleed: a host juggling multiple open sessions (e.g. a
+             * server wrapping several concurrent agent sessions) that called the
+             * global `files.list()` while a DIFFERENT session was "active" would
+             * silently read/write the wrong sandbox. Each call here auto-provisions
+             * via `ensureReady()` (same as `send`/`abort`/`stream`), then runs
+             * against this handle's own runtime URL. Same 12-op surface as the
+             * global `files` namespace, built from the same parameterized core
+             * (`@kortix/sdk/files`'s exports all take an optional trailing
+             * `baseUrl` — this just always supplies THIS session's).
+             */
+            files: {
+                list: (dirPath: string) => Promise<F.FileNode[]>;
+                read: (filePath: string) => Promise<F.FileContent>;
+                readBlob: (filePath: string) => Promise<Blob>;
+                status: () => Promise<F.GitFileStatus[]>;
+                findFiles: (query: string, options?: {
+                    type?: "file" | "directory";
+                    limit?: number;
+                }) => Promise<string[]>;
+                findText: (pattern: string) => Promise<F.FindMatch[]>;
+                upload: (file: File | Blob, targetPath?: string, filename?: string) => Promise<F.UploadResult[]>;
+                create: (filePath: string) => Promise<F.UploadResult[]>;
+                copy: (sourcePath: string, destPath: string) => Promise<F.UploadResult[]>;
+                remove: (filePath: string) => Promise<boolean>;
+                mkdir: (dirPath: string) => Promise<boolean>;
+                rename: (from: string, to: string) => Promise<boolean>;
+            };
+        };
+    };
+    session: (projectId: string, sessionId: string) => {
+        get: (opts?: {
+            showErrors?: boolean;
+        }) => Promise<P.ProjectSession>;
+        update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
+        delete: () => Promise<{
+            ok: boolean;
+        }>;
+        start: (waitMs?: number | undefined) => Promise<P.SessionStartResult | null>;
+        restart: () => Promise<{
+            ok: boolean;
+            session_id: string;
+            status: string;
+        }>;
+        stop: () => Promise<{
+            ok: boolean;
+            session_id: string;
+            status: string;
+        }>;
+        setSharing: (intent: Parameters<typeof P.setProjectSessionSharing>[2]) => Promise<P.ProjectSession>;
+        previews: () => Promise<{
+            candidates: P.SessionPreviewCandidate[];
+        }>;
+        commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
+        publicShares: {
+            list: () => Promise<{
+                shares: P.SessionPublicShare[];
+            }>;
+            create: (input: P.CreateSessionPublicShareInput) => Promise<{
+                share: P.SessionPublicShare;
+            }>;
+            revoke: (shareId: string) => Promise<{
+                share: P.SessionPublicShare;
+            }>;
+        };
+        /** Per-session audit trail of executor-gated agent actions. */
+        audit: (limit?: number, options?: {
+            showErrors?: boolean;
+        }) => Promise<P.SessionAudit>;
+        /** Compact server-side transcript read (text + tool calls, no tool inputs/outputs) — callable with project-scoped session tokens. */
+        transcript: (options?: Parameters<typeof P.getSessionTranscript>[2]) => Promise<P.SessionTranscript>;
+        /**
+         * Resolve THIS handle's own runtime (idempotent): provisions/resumes the
+         * sandbox (long-poll until ready) and caches the resolved OpenCode session
+         * id + runtime URL + sandbox id for every other call on this handle. Call
+         * this (or `send`/`abort`, which call it internally) before `.runtime`,
+         * `.health()`, `.previewUrl()`, or `.proxyUrl()` — those throw
+         * `SessionNotReadyError` instead of falling back to whatever sandbox
+         * happens to be globally active.
+         */
+        ensureReady: () => Promise<SessionRuntimeEntry>;
+        /**
+         * Liveness/readiness of THIS session's runtime (`GET /kortix/health`).
+         * Unlike `.previewUrl()`/`.proxyUrl()`/`.runtime`, this never throws
+         * `SessionNotReadyError` — a health poller (e.g. a header dot ticking
+         * every 15s on a fresh inline handle) needs to be callable BEFORE the
+         * session has ever resolved a runtime. It degrades to the same graceful
+         * `{ status: 0, ok: false }` shape `getSessionHealth` already returns for
+         * "no URL yet", instead of forcing every caller to guard with `ensureReady()`.
+         */
+        health: (init?: RequestInit) => Promise<import("./index.js").SessionHealthResult>;
+        /** Proxy/preview URL for a port THIS session's runtime exposes. */
+        previewUrl: (port: number, path?: string) => string;
+        /** Rewrite a localhost URL the agent printed into a reachable proxy URL. */
+        proxyUrl: (url?: string) => string | undefined;
+        /** Pick the model `send` will use for subsequent prompts (until changed). */
+        setModel: (model: SessionModel | undefined) => void;
+        /** Pick the agent `send` will use for subsequent prompts (until changed). */
+        setAgent: (agent: string | undefined) => void;
+        /**
+         * Provision/resume if needed, then send a text prompt to the agent. A
+         * per-call `{ model, agent }` overrides the sticky setModel/setAgent
+         * choices for this message only.
+         */
+        send: (text: string, opts?: {
+            model?: SessionModel;
+            agent?: string;
+        }) => Promise<({
+            data: {
+                info: import("@opencode-ai/sdk/v2/types").AssistantMessage;
+                parts: Array<import("@opencode-ai/sdk/v2/types").Part>;
+            };
+            error: undefined;
+        } | {
+            data: undefined;
+            error: import("@opencode-ai/sdk/v2/types").EffectHttpApiErrorBadRequest | import("@opencode-ai/sdk/v2/types").InvalidRequestError | import("@opencode-ai/sdk/v2/types").NotFoundError;
+        }) & {
+            request: Request;
+            response: Response;
+        }>;
+        /** Abort the agent's current run in this session. */
+        abort: () => Promise<({
+            data: boolean;
+            error: undefined;
+        } | {
+            data: undefined;
+            error: import("@opencode-ai/sdk/v2/types").EffectHttpApiErrorBadRequest | import("@opencode-ai/sdk/v2/types").InvalidRequestError;
+        }) & {
+            request: Request;
+            response: Response;
+        }>;
+        /**
+         * Live SSE stream of THIS session's runtime events (message/part
+         * updates, session status, permissions/questions, lsp diagnostics, …).
+         * A thin facade over the framework-free `openEventStream` primitive
+         * (`@kortix/sdk`'s `openEventStream`, also used verbatim by
+         * `@kortix/sdk/react`'s `useOpenCodeEventStream`): resolves THIS
+         * handle's own runtime first (`ensureReady()`), then connects a client
+         * bound to that runtime URL — never the module-global "active" one, so
+         * two session handles on two different sandboxes never cross wires.
+         * Framework-free — safe to call from a server-side "Kortix as a
+         * Backend" wrapper (Node/Bun), a worker, a CLI, or any non-React host.
+         *
+         * Handles connect/reconnect/backoff, a 15s heartbeat watchdog, and
+         * event coalescing internally. Call `handle.close()` to stop.
+         *
+         *   const handle = await session.stream({ onEvent: (e) => console.log(e) });
+         *   // later
+         *   handle.close();
+         */
+        stream: (opts: {
+            onEvent: (event: OpenCodeEvent) => void;
+            onGapRehydrate?: (gapMs: number) => void;
+            signal?: AbortSignal;
+        }) => Promise<EventStreamHandle>;
+        readonly runtime: OpencodeClient;
+        /**
+         * Workspace file operations (daemon `/file` + `/find`) bound to THIS
+         * session's own resolved runtime — never the module-global "active"
+         * sandbox the top-level `@kortix/sdk` `files` export follows. Fixes a
+         * cross-session bleed: a host juggling multiple open sessions (e.g. a
+         * server wrapping several concurrent agent sessions) that called the
+         * global `files.list()` while a DIFFERENT session was "active" would
+         * silently read/write the wrong sandbox. Each call here auto-provisions
+         * via `ensureReady()` (same as `send`/`abort`/`stream`), then runs
+         * against this handle's own runtime URL. Same 12-op surface as the
+         * global `files` namespace, built from the same parameterized core
+         * (`@kortix/sdk/files`'s exports all take an optional trailing
+         * `baseUrl` — this just always supplies THIS session's).
+         */
+        files: {
+            list: (dirPath: string) => Promise<F.FileNode[]>;
+            read: (filePath: string) => Promise<F.FileContent>;
+            readBlob: (filePath: string) => Promise<Blob>;
+            status: () => Promise<F.GitFileStatus[]>;
+            findFiles: (query: string, options?: {
+                type?: "file" | "directory";
+                limit?: number;
+            }) => Promise<string[]>;
+            findText: (pattern: string) => Promise<F.FindMatch[]>;
+            upload: (file: File | Blob, targetPath?: string, filename?: string) => Promise<F.UploadResult[]>;
+            create: (filePath: string) => Promise<F.UploadResult[]>;
+            copy: (sourcePath: string, destPath: string) => Promise<F.UploadResult[]>;
+            remove: (filePath: string) => Promise<boolean>;
+            mkdir: (dirPath: string) => Promise<boolean>;
+            rename: (from: string, to: string) => Promise<boolean>;
+        };
+    };
+    /** GitHub App installation + repository linking (account-scoped). */
+    github: {
+        linkRepository: typeof P.linkRepository;
+        getInstallation: typeof P.getGitHubInstallation;
+        listInstallations: typeof P.listGitHubInstallations;
+        listRepositories: typeof P.listGitHubRepositories;
+        saveInstallation: typeof P.saveGitHubInstallation;
+        deleteInstallation: typeof P.deleteGitHubInstallation;
+    };
+    /** Billing read surface — credits/subscription/tier/transactions (not project-scoped). */
+    billing: {
+        accountState: typeof P.getAccountState;
+        accountStateMinimal: typeof P.getAccountStateMinimal;
+        transactions: typeof P.listBillingTransactions;
+        transactionsSummary: typeof P.getBillingTransactionsSummary;
+        creditBreakdown: typeof P.getBillingCreditBreakdown;
+        usageHistory: typeof P.getBillingUsageHistory;
+        tierConfigurations: typeof P.getBillingTierConfigurations;
+        /** Stripe checkout — start a subscription and confirm it post-redirect. */
+        checkout: {
+            createSession: (input: Parameters<typeof P.createCheckoutSession>[0]) => Promise<P.CheckoutSessionResult>;
+            confirmSession: (sessionId: string, accountId?: string) => Promise<P.ConfirmCheckoutSessionResult>;
+        };
+        /** Manage an existing subscription (portal, cancel/reactivate, downgrade). */
+        subscription: {
+            createPortalSession: (returnUrl: string, accountId?: string) => Promise<P.PortalSessionResult>;
+            cancel: (feedback?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            reactivate: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            scheduleDowngrade: (targetTierKey: string, commitmentType?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            cancelScheduledChange: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            prorationPreview: (newPriceId: string, accountId?: string) => Promise<P.ProrationPreviewResult>;
+        };
+        /** One-off credit purchases + recurring auto-topup configuration. */
+        credits: {
+            purchase: (input: Parameters<typeof P.purchaseCredits>[0]) => Promise<P.PurchaseCreditsResult>;
+            autoTopupSettings: (accountId?: string) => Promise<P.AutoTopupSettings>;
+            configureAutoTopup: (input: Parameters<typeof P.configureAutoTopup>[0]) => Promise<P.AutoTopupSettings>;
+        };
+    };
+    /** Public share links for a sandbox port (`/v1/p/share`, sandbox-scoped). */
+    sandboxShares: {
+        list: typeof P.listSandboxShares;
+        create: typeof P.createSandboxShare;
+        revoke: typeof P.revokeSandboxShare;
+    };
+    /** Speech-to-text transcription (`/transcription` — not project-scoped). */
+    transcribe: typeof P.transcribeAudio;
+    /** Deployment-wide Pipedream/easy-connect availability flag (not project-scoped). */
+    connectStatus: typeof P.getConnectStatus;
+    /** Public marketplace catalog browse + sources (`/v1/marketplace/*`, not project-scoped). */
+    marketplace: {
+        items: (options?: Parameters<typeof P.listMarketplaceCatalogItems>[0]) => Promise<P.MarketplaceItemsResponse>;
+        item: (id: string) => Promise<Record<string, unknown>>;
+        itemFile: (id: string, path: string) => Promise<P.MarketplaceItemFile>;
+        marketplaces: () => Promise<P.MarketplacesResponse>;
+        featured: () => Promise<P.FeaturedMarketplacesResponse>;
+        sources: {
+            list: () => Promise<P.MarketplaceSourcesResponse>;
+            add: (input: Parameters<typeof P.addMarketplaceSource>[0]) => Promise<P.AddMarketplaceSourceResponse>;
+            remove: (id: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+    };
+    /** The pasted-API-key UX check — `GET /accounts/me`, never throws. */
+    validateToken: typeof P.validateToken;
+    /** Escape hatch: the typed opencode client for the active sandbox. */
+    runtime: typeof runtime;
+};
+export type Kortix = ReturnType<typeof createKortix>;
+/** The id-bound project handle returned by `kortix.project(id)`. */
+export type ProjectHandle = ReturnType<Kortix['project']>;
+/** The id-bound session handle returned by `kortix.session(pid, sid)`. */
+export type SessionHandle = ReturnType<Kortix['session']>;
+type DropFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];
+export {};
+//# sourceMappingURL=kortix.d.ts.map