openpond 0.0.30-bootstrap.0

package/dist/indicators.d.ts

@@ -0,0 +1,38 @@
+export type Bar = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};
+export type MacdResult = {
+    macd: number;
+    signalLine: number;
+    histogram: number;
+};
+export type MaCrossSignal = "neutral" | "bullish" | "bearish" | "bullish-cross" | "bearish-cross";
+export type MaCrossResult = {
+    fast: number;
+    slow: number;
+    signal: MaCrossSignal;
+};
+export type BollingerResult = {
+    middle: number;
+    upper: number;
+    lower: number;
+};
+export type PriceChangeResult = {
+    previous: number;
+    percent: number;
+};
+export declare function computeRsi(values: number[], period?: number): number | null;
+export declare function computeSmaSeries(values: number[], period: number): number[];
+export declare function computeSma(values: number[], period: number): number | null;
+export declare function computeEmaSeries(values: number[], period: number): number[];
+export declare function computeEma(values: number[], period: number): number | null;
+export declare function computeMacd(values: number[]): MacdResult | null;
+export declare function computeMaCross(values: number[], type: "sma" | "ema", fastPeriod: number, slowPeriod: number): MaCrossResult | null;
+export declare function computeBollinger(values: number[], period?: number, multiplier?: number): BollingerResult | null;
+export declare function computePriceChange(values: number[], lookback?: number): PriceChangeResult | null;
+export declare function computeAtr(bars: Bar[], period?: number): number | null;

package/dist/opchat-smoke.d.ts

@@ -0,0 +1,47 @@
+import { type HostedChatUsage } from "./hosted-chat.js";
+export type OpChatSmokeOptions = {
+    apiBaseUrl: string;
+    token: string;
+    defaultModel?: string;
+    compatibilityModel?: string;
+    invalidModel?: string;
+    skipStream?: boolean;
+    skipTool?: boolean;
+    log?: (line: string) => void;
+};
+export type OpChatSmokeSummary = {
+    apiBaseUrl: string;
+    listedModels: string[];
+    defaultModel: string;
+    compatibilityModel: string;
+    modelLookups: string[];
+    invalidModelError: string;
+    nonStreaming: OpChatCompletionSummary;
+    compatibilityNonStreaming: OpChatCompletionSummary;
+    streaming?: OpChatStreamSummary;
+    toolCalling?: OpChatToolSummary;
+};
+export type OpChatCompletionSummary = {
+    model: string;
+    id: string | null;
+    finishReason: string | null;
+    textPreview: string;
+    usage: HostedChatUsage | null;
+};
+export type OpChatStreamSummary = {
+    model: string;
+    textDeltaCount: number;
+    textPreview: string;
+    firstTextMs: number | null;
+    totalMs: number;
+    finishReason: string | null;
+    usage: HostedChatUsage | null;
+};
+export type OpChatToolSummary = {
+    model: string;
+    toolCallCount: number;
+    toolNames: string[];
+    finishReason: string | null;
+    followUp: OpChatCompletionSummary;
+};
+export declare function runOpChatSmoke(options: OpChatSmokeOptions): Promise<OpChatSmokeSummary>;

package/dist/private-json-file.d.ts

@@ -0,0 +1,3 @@
+export declare function openPondConfigDirectory(): string;
+export declare function writePrivateJsonFile(filePath: string, value: unknown): Promise<void>;
+export declare function updatePrivateJsonFile<T>(filePath: string, fallback: () => T, update: (current: T) => T | Promise<T>): Promise<T>;

package/dist/profile/local-profile-types.d.ts

@@ -0,0 +1,160 @@
+import type { LocalOpenPondProfileCheckStatus, LocalOpenPondProfileHostedMaterializationStatus, LocalOpenPondProfileHostedPublishStatus, LocalOpenPondProfileHostedRunSummary, LocalOpenPondProfileHostedSourceCheckStatus } from "../config.js";
+export type OpenPondProfileAgent = {
+    id: string;
+    name: string;
+    path: string;
+    enabled: boolean;
+};
+export type OpenPondProfileSkill = {
+    name: string;
+    description: string;
+    path: string;
+    scope: "profile";
+    enabled: boolean;
+    sourcePath: string;
+    charCount: number;
+    sourceHash: string;
+    validationStatus: "valid" | "warning" | "error";
+    validationMessages: string[];
+};
+export type OpenPondProfileGitFileChange = {
+    path: string;
+    originalPath?: string | null;
+    indexStatus: string | null;
+    worktreeStatus: string | null;
+    status: string;
+    category: "added" | "modified" | "deleted" | "renamed" | "untracked" | "changed";
+};
+export type OpenPondProfileGitState = {
+    isRepo: boolean;
+    branch: string | null;
+    head: string | null;
+    shortHead: string | null;
+    dirty: boolean;
+    upstream: string | null;
+    ahead: number | null;
+    behind: number | null;
+    remoteUrl: string | null;
+    files: OpenPondProfileGitFileChange[];
+    error: string | null;
+};
+export type OpenPondProfileActionCatalogEntry = {
+    id: string;
+    name?: string | null;
+    label?: string | null;
+    description?: string | null;
+    agentId?: string | null;
+    sourcePath?: string | null;
+    sourceActionId?: string | null;
+    visibility?: string | null;
+    inputSchema?: string | Record<string, unknown> | null;
+    outputSchema?: string | Record<string, unknown> | null;
+    approvalPolicy?: Record<string, unknown> | null;
+    artifactPolicy?: Record<string, unknown> | null;
+    setupRequirements?: Record<string, unknown>[];
+    mcp?: Record<string, unknown> | null;
+    schedulePolicy?: Record<string, unknown> | null;
+    trace?: Record<string, unknown> | null;
+    implementation?: Record<string, unknown> | null;
+    invokesModel?: boolean;
+};
+export type OpenPondProfileSetupRequirement = {
+    ref: string;
+    source: "action_catalog" | "source_upload_metadata";
+    actionId: string | null;
+    kind: string | null;
+    label: string;
+    status: string;
+    required: boolean;
+    blocking: boolean;
+};
+export type OpenPondProfileSetupGate = {
+    status: "ready" | "setup_required" | "blocked";
+    requirementCount: number;
+    blockingCount: number;
+    optionalMissingCount: number;
+    readyCount: number;
+    requirements: OpenPondProfileSetupRequirement[];
+    blockingRequirements: OpenPondProfileSetupRequirement[];
+};
+export type OpenPondProfileCatalogState = {
+    actionCount: number;
+    generatedAt: string | null;
+    manifestPath: string | null;
+    registryPath: string | null;
+    stale: boolean;
+    error: string | null;
+};
+export type OpenPondProfileSkillCatalogState = {
+    skillCount: number;
+    generatedAt: string | null;
+    stale: boolean;
+    error: string | null;
+};
+export type OpenPondProfileDiffSummary = {
+    changedAgents: string[];
+    newAgents: string[];
+    deletedAgents: string[];
+    changedSkills: string[];
+    changedActions: string[];
+    changedExtensions: string[];
+    setupChanges: string[];
+    envRequirementChanges: string[];
+    files: OpenPondProfileGitFileChange[];
+};
+export type OpenPondProfileHostedBinding = {
+    teamId: string | null;
+    projectId: string | null;
+    sourceRef: string | null;
+    sourceCommitSha: string | null;
+    lastPushedAt: string | null;
+    lastPushedLocalHead: string | null;
+    lastPushedHostedHead: string | null;
+    promotionStatus: string | null;
+    hostedRunStatus: string | null;
+    localGoalId: string | null;
+    hostedGoalId: string | null;
+    hostedRunAgentId: string | null;
+    hostedRunId: string | null;
+    hostedRunAt: string | null;
+    hostedSourceMaterialization: LocalOpenPondProfileHostedMaterializationStatus | null;
+    hostedSourceCheck: LocalOpenPondProfileHostedSourceCheckStatus | null;
+    hostedPublish: LocalOpenPondProfileHostedPublishStatus | null;
+    hostedRun: LocalOpenPondProfileHostedRunSummary | null;
+};
+export type OpenPondProfileSummary = {
+    state: "none" | "ready" | "dirty" | "pending_commit" | "error";
+    message: string;
+    agentCount: number;
+    actionCount: number;
+    defaultAction: string | null;
+    checkFresh: boolean;
+    checkStaleReason: string | null;
+    localHead: string | null;
+    hostedHead: string | null;
+};
+export type OpenPondProfileState = {
+    mode: "none" | "local";
+    repoPath: string | null;
+    activeProfile: string | null;
+    sourcePath: string | null;
+    manifestPath: string | null;
+    agents: OpenPondProfileAgent[];
+    skills: OpenPondProfileSkill[];
+    git: OpenPondProfileGitState | null;
+    catalog: OpenPondProfileCatalogState;
+    skillCatalog: OpenPondProfileSkillCatalogState;
+    actionCatalog: OpenPondProfileActionCatalogEntry[];
+    sourceSetupRequirements: Record<string, unknown>[];
+    setupGate: OpenPondProfileSetupGate;
+    diff: OpenPondProfileDiffSummary;
+    hosted: OpenPondProfileHostedBinding | null;
+    summary: OpenPondProfileSummary;
+    lastCheck: LocalOpenPondProfileCheckStatus | null;
+    error: string | null;
+};
+export declare function emptyProfileCatalogState(error?: string | null): OpenPondProfileCatalogState;
+export declare function emptyProfileSkillCatalogState(error?: string | null): OpenPondProfileSkillCatalogState;
+export declare function emptyProfileSetupGate(): OpenPondProfileSetupGate;
+export declare function emptyProfileDiffSummary(): OpenPondProfileDiffSummary;
+export declare function emptyProfileSummary(error?: string | null): OpenPondProfileSummary;

package/dist/profile/local-profile.d.ts

@@ -0,0 +1,69 @@
+import { type LocalOpenPondProfileConfig, type LocalOpenPondProfilePushStatus } from "../config.js";
+import { type OpenPondProfileState } from "./local-profile-types.js";
+export declare const PROFILE_REPO_MANIFEST = "openpond-profile.json";
+export declare const PROFILE_MANIFEST = "settings/profile.yaml";
+export declare const DEFAULT_LOCAL_PROFILE = "default";
+export declare const DEFAULT_PROFILE_AGENT = "default";
+export type ProfileRepoManifest = {
+    schema: "openpond.profileRepo.v1";
+    defaultProfile: string;
+    profiles: Record<string, {
+        path: string;
+        defaultAgent?: string;
+        enabledAgents?: string[];
+    }>;
+};
+export type { OpenPondProfileActionCatalogEntry, OpenPondProfileAgent, OpenPondProfileCatalogState, OpenPondProfileDiffSummary, OpenPondProfileGitFileChange, OpenPondProfileGitState, OpenPondProfileHostedBinding, OpenPondProfileSetupGate, OpenPondProfileSetupRequirement, OpenPondProfileSkill, OpenPondProfileSkillCatalogState, OpenPondProfileState, OpenPondProfileSummary, } from "./local-profile-types.js";
+export { OpenPondProfileSetupRequiredError, assertOpenPondProfileActionReady, buildOpenPondProfileSetupGate, formatOpenPondProfileSetupRequirement, } from "./profile-setup-gate.js";
+export type { LocalOpenPondProfileCheckStatus, LocalOpenPondProfilePushStatus, } from "../config.js";
+export { collectProfileSourceUploadEntries, type OpenPondProfileSourceUpload, type OpenPondProfileSourceUploadEntry, } from "./profile-source-upload.js";
+export { hostedPublishStatusFromPayload, hostedRunStatusFromRunSummary, hostedRunSummaryFromPayload, hostedSourceCheckStatusFromPayload, } from "./profile-promotion.js";
+export type InitLocalProfileInput = {
+    repoPath?: string;
+    profile?: string;
+    template?: string;
+    force?: boolean;
+};
+export declare function mergeProfileRepoManifestEntry(existing: ProfileRepoManifest["profiles"][string] | undefined, profilePath: string): ProfileRepoManifest["profiles"][string];
+export declare function mergeActiveLocalProfileConfig(existing: LocalOpenPondProfileConfig | undefined, repoPath: string, profile: string): LocalOpenPondProfileConfig;
+export type RunProfileCommandInput = {
+    command: "inspect" | "build" | "validate" | "eval" | "run";
+    args?: string[];
+    cwd?: string;
+    inherit?: boolean;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+};
+export declare function defaultLocalProfileRepoPath(): string;
+export declare function emptyProfileState(error?: string | null): OpenPondProfileState;
+export declare function initLocalProfileRepo(input?: InitLocalProfileInput): Promise<OpenPondProfileState>;
+export declare function loadLocalProfileRepo(repoPathInput: string, profileInput?: string): Promise<OpenPondProfileState>;
+export declare function loadOpenPondProfileState(): Promise<OpenPondProfileState>;
+export declare function requireActiveLocalProfile(): Promise<{
+    config: LocalOpenPondProfileConfig;
+    state: OpenPondProfileState;
+}>;
+export declare function runProfileSdkCommand(input: RunProfileCommandInput): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function runAgentSdkProjectCommand(input: RunProfileCommandInput & {
+    cwd: string;
+    throwOnFailure?: boolean;
+}): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+}>;
+export declare function runProfileCheck(kind: string | undefined): Promise<void>;
+export declare function commitActiveProfileChanges(message?: string): Promise<{
+    committed: boolean;
+    stdout: string;
+    stderr: string;
+    state: OpenPondProfileState;
+}>;
+export declare function saveProfilePushStatus(status: LocalOpenPondProfilePushStatus): Promise<void>;

package/dist/profile/profile-catalog.d.ts

@@ -0,0 +1,14 @@
+import type { OpenPondProfileActionCatalogEntry, OpenPondProfileCatalogState } from "./local-profile-types.js";
+type LoadedProfileCatalog = {
+    catalog: OpenPondProfileCatalogState;
+    actionCatalog: OpenPondProfileActionCatalogEntry[];
+    sourceSetupRequirements: Record<string, unknown>[];
+};
+export type ProfileActionCatalogSource = {
+    agentId: string;
+    sourcePath: string;
+    preferred?: boolean;
+};
+export declare function loadProfileActionCatalog(sourcePath: string): Promise<LoadedProfileCatalog>;
+export declare function loadProfileActionCatalogForSources(sources: ProfileActionCatalogSource[]): Promise<LoadedProfileCatalog>;
+export {};

package/dist/profile/profile-git.d.ts

@@ -0,0 +1,17 @@
+import type { OpenPondProfileGitState } from "./local-profile-types.js";
+export declare function ensureProfileGitRepo(repoPath: string): Promise<void>;
+export declare function loadProfileGitState(repoPath: string): Promise<OpenPondProfileGitState>;
+export declare function commitProfileChanges(repoPath: string, message: string): Promise<{
+    committed: boolean;
+    stdout: string;
+    stderr: string;
+    state: OpenPondProfileGitState;
+}>;
+export declare function profileGitHead(repoPath: string): Promise<string | null>;
+export declare function runGitCommand(repoPath: string, args: string[], options?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;

package/dist/profile/profile-promotion.d.ts

@@ -0,0 +1,21 @@
+import type { LocalOpenPondProfileHostedPublishStatus, LocalOpenPondProfileHostedRunSummary, LocalOpenPondProfileHostedSourceCheckStatus } from "../config.js";
+export declare function hostedSourceCheckStatusFromPayload(input: {
+    agentId: string;
+    status: string;
+    deployPlan?: unknown;
+    checkResult?: unknown;
+    checkedAt?: string;
+    error?: string | null;
+}): LocalOpenPondProfileHostedSourceCheckStatus;
+export declare function hostedPublishStatusFromPayload(input: {
+    agentId: string;
+    publishResult: unknown;
+    status?: string;
+    error?: string | null;
+}): LocalOpenPondProfileHostedPublishStatus;
+export declare function hostedRunSummaryFromPayload(input: {
+    agentId: string;
+    runResult: unknown;
+    error?: string | null;
+}): LocalOpenPondProfileHostedRunSummary;
+export declare function hostedRunStatusFromRunSummary(summary: LocalOpenPondProfileHostedRunSummary | null | undefined): "not_started" | "running" | "passed" | "failed";

package/dist/profile/profile-setup-gate.d.ts

@@ -0,0 +1,22 @@
+import type { OpenPondProfileActionCatalogEntry, OpenPondProfileSetupGate, OpenPondProfileSetupRequirement } from "./local-profile-types.js";
+type BuildOpenPondProfileSetupGateInput = {
+    actionCatalog: OpenPondProfileActionCatalogEntry[];
+    sourceSetupRequirements?: Record<string, unknown>[];
+    actionId?: string | null;
+};
+export declare class OpenPondProfileSetupRequiredError extends Error {
+    readonly code = "agent_source_setup_required";
+    readonly details: {
+        error: "agent_source_setup_required";
+        actionId: string;
+        setupGate: OpenPondProfileSetupGate;
+        missing: string[];
+        blockingSetupRequirements: OpenPondProfileSetupRequirement[];
+        setupRequirements: OpenPondProfileSetupRequirement[];
+    };
+    constructor(actionId: string, setupGate: OpenPondProfileSetupGate);
+}
+export declare function buildOpenPondProfileSetupGate(input: BuildOpenPondProfileSetupGateInput): OpenPondProfileSetupGate;
+export declare function assertOpenPondProfileActionReady(actionId: string, setupGate: OpenPondProfileSetupGate): void;
+export declare function formatOpenPondProfileSetupRequirement(requirement: OpenPondProfileSetupRequirement): string;
+export {};

package/dist/profile/profile-skills.d.ts

@@ -0,0 +1,30 @@
+import type { OpenPondProfileSkill, OpenPondProfileSkillCatalogState } from "./local-profile-types.js";
+export declare const PROFILE_SKILLS_DIR = "skills";
+export declare const PROFILE_SKILL_FILE = "SKILL.md";
+export declare const PROFILE_SKILL_MAX_CHARS = 80000;
+type LoadedProfileSkills = {
+    skillCatalog: OpenPondProfileSkillCatalogState;
+    skills: OpenPondProfileSkill[];
+};
+export type OpenPondProfileSkillReadResult = {
+    name: string;
+    description: string;
+    body: string;
+    path: string;
+    sourcePath: string;
+    sourceHash: string;
+    charCount: number;
+};
+type ParsedSkillMarkdown = {
+    name: string | null;
+    description: string | null;
+    body: string;
+    messages: string[];
+};
+export declare function loadProfileSkills(profileSourcePath: string): Promise<LoadedProfileSkills>;
+export declare function parseProfileSkillMarkdown(markdown: string): ParsedSkillMarkdown;
+export declare function readProfileSkill(input: {
+    profileSourcePath: string;
+    name: string;
+}): Promise<OpenPondProfileSkillReadResult>;
+export {};

package/dist/profile/profile-source-upload.d.ts

@@ -0,0 +1,29 @@
+export type OpenPondProfileSourceUploadEntry = {
+    path: string;
+    type: "file";
+    contentsBase64: string;
+};
+export type OpenPondProfileSourceUpload = {
+    entries: OpenPondProfileSourceUploadEntry[];
+    fileCount: number;
+    totalBytes: number;
+    limits: OpenPondProfileSourceUploadLimits;
+    transport: OpenPondProfileSourceUploadTransport;
+};
+export type OpenPondProfileSourceUploadLimits = {
+    maxFiles: number;
+    maxFileBytes: number;
+    maxTotalBytes: number;
+    concurrency: number;
+};
+export type OpenPondProfileSourceUploadTransport = {
+    mode: "single_json_payload";
+    chunkingSupported: false;
+};
+export declare const PROFILE_SOURCE_UPLOAD_MAX_FILES = 1500;
+export declare const PROFILE_SOURCE_UPLOAD_MAX_FILE_BYTES: number;
+export declare const PROFILE_SOURCE_UPLOAD_MAX_BYTES: number;
+export declare const PROFILE_SOURCE_UPLOAD_CONCURRENCY = 8;
+export declare const PROFILE_SOURCE_UPLOAD_LIMITS: OpenPondProfileSourceUploadLimits;
+export declare const PROFILE_SOURCE_UPLOAD_TRANSPORT: OpenPondProfileSourceUploadTransport;
+export declare function collectProfileSourceUploadEntries(repoPath: string): Promise<OpenPondProfileSourceUpload>;

package/dist/profile/source-upload-cache.d.ts

@@ -0,0 +1,29 @@
+export declare const SOURCE_UPLOAD_CACHE_PATH = ".openpond/source-upload-cache.json";
+export type SourceUploadCacheFile = {
+    path: string;
+    absolutePath: string;
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+};
+export type SourceUploadCacheEntry = {
+    path: string;
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    sha256: string;
+    contentsBase64: string;
+};
+export type SourceUploadMaterializedEntry = {
+    path: string;
+    type: "file";
+    contentsBase64: string;
+};
+export type SourceUploadMaterializedFile = {
+    file: SourceUploadCacheFile;
+    entry: SourceUploadMaterializedEntry;
+    sha256: string;
+};
+export declare function readSourceUploadCache(rootPath: string): Promise<Map<string, SourceUploadCacheEntry>>;
+export declare function materializeSourceUploadFile(file: SourceUploadCacheFile, cache: Map<string, SourceUploadCacheEntry>): Promise<SourceUploadMaterializedFile>;
+export declare function writeSourceUploadCache(rootPath: string, files: SourceUploadMaterializedFile[]): Promise<void>;

package/dist/sandbox/async-request-options.d.ts

@@ -0,0 +1,2 @@
+import type { SandboxAsyncRequestOptions } from "./types/index.js";
+export declare function asyncRequestHeaders(options?: SandboxAsyncRequestOptions): HeadersInit | undefined;

package/dist/sandbox/client-handles.d.ts

@@ -0,0 +1,113 @@
+import type { OpenPondSandboxClient } from "./client.js";
+import type { SandboxAgentRunInput, SandboxAgentEditWorkItemOpenInput, SandboxAgentSourceChecksRequestInput, SandboxAgentSourcePublishInput, SandboxAgentUpdateInput, SandboxAgentUpsertInput, SandboxCodingWorkItemActivityListInput, SandboxCodingWorkItemBackgroundInput, SandboxCodingWorkItemChatInput, SandboxCodingWorkItemGetInput, SandboxCodingWorkItemPromotionInput, SandboxCreateInput, SandboxAsyncRequestOptions, SandboxProjectUpdateInput, SandboxProjectUpsertInput, SandboxProjectSourceUploadInput, SandboxRuntime, SandboxRuntimeCheckpointInput, SandboxRuntimeCreateInput, SandboxRuntimeEventInput, SandboxRuntimePromoteInput, SandboxRuntimeSourcePreserveInput, SandboxRuntimeSandboxCreateInput, SandboxRuntimeTransitionInput, OpenPondHostedProfilePushInput, OpenPondHostedProfilePushResponse, OpenPondHostedProfileSummary } from "./types/index.js";
+export declare function createSandboxRuntimeNamespace(client: OpenPondSandboxClient): {
+    list: (input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }) => Promise<SandboxRuntime[]>;
+    create: (input: SandboxRuntimeCreateInput) => Promise<SandboxRuntime>;
+    handle: (runtimeId: string, initial?: SandboxRuntime | null) => import("src/index.js").OpenPondSandboxRuntimeHandle;
+    get: (runtimeId: string) => Promise<SandboxRuntime>;
+    createSandbox: (runtimeId: string, input?: SandboxRuntimeSandboxCreateInput, options?: SandboxAsyncRequestOptions) => Promise<import("src/index.js").SandboxRuntimeSandboxResponse>;
+    updateStatus: (runtimeId: string, input: SandboxRuntimeTransitionInput) => Promise<SandboxRuntime>;
+    events: (runtimeId: string) => Promise<import("src/index.js").SandboxRuntimeEventsResponse>;
+    event: (runtimeId: string, input: SandboxRuntimeEventInput) => Promise<import("src/index.js").SandboxRuntimeEventResponse>;
+    checkpoint: (runtimeId: string, input?: SandboxRuntimeCheckpointInput) => Promise<SandboxRuntime>;
+    promote: (runtimeId: string, input: SandboxRuntimePromoteInput, options?: {
+        teamId?: string;
+    }) => Promise<import("src/index.js").SandboxRuntimePromoteResponse>;
+    preserveSource: (runtimeId: string, input?: SandboxRuntimeSourcePreserveInput, options?: {
+        teamId?: string;
+    }) => Promise<import("src/index.js").SandboxRuntimeSourcePreserveResponse>;
+};
+export declare function createSandboxNamespace(client: OpenPondSandboxClient): {
+    list: (input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }) => Promise<import("src/index.js").SandboxRecord[]>;
+    create: (input: SandboxCreateInput) => Promise<import("src/index.js").SandboxRecord>;
+    get: (sandboxId: string) => Promise<import("src/index.js").SandboxRecord>;
+    pricing: () => Promise<import("src/index.js").SandboxPricingResponse>;
+    costs: (input?: {
+        teamId?: string;
+        projectId?: string;
+        agentId?: string;
+    }) => Promise<import("src/index.js").SandboxCostSummaryResponse>;
+};
+export declare function createSandboxProjectNamespace(client: OpenPondSandboxClient): {
+    list: (input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProject[]>;
+    upsert: (input: SandboxProjectUpsertInput) => Promise<import("src/index.js").SandboxProject>;
+    upsertGitRemote: (input: SandboxProjectUpsertInput) => Promise<import("src/index.js").SandboxProjectGitRemoteResponse>;
+    get: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProject>;
+    update: (projectId: string, input: SandboxProjectUpdateInput) => Promise<import("src/index.js").SandboxProject>;
+    sync: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProject>;
+    ensureGitRemote: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProjectGitRemoteResponse>;
+    getGitRemote: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProjectGitRemoteResponse>;
+    git: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProjectGitRemoteResponse>;
+    uploadSource: (projectId: string, input: SandboxProjectSourceUploadInput) => Promise<import("src/index.js").SandboxProject>;
+    archive: (projectId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxProject>;
+};
+export declare function createSandboxProfileNamespace(client: OpenPondSandboxClient): {
+    get(input: {
+        teamId: string;
+    }): Promise<OpenPondHostedProfileSummary | null>;
+    status(input: {
+        teamId: string;
+    }): Promise<OpenPondHostedProfileSummary | null>;
+    ensureHosted(input: {
+        teamId: string;
+    }): Promise<OpenPondHostedProfileSummary>;
+    push(input: OpenPondHostedProfilePushInput): Promise<OpenPondHostedProfilePushResponse>;
+};
+export declare function createSandboxAgentNamespace(client: OpenPondSandboxClient): {
+    list: (input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxAgent[]>;
+    upsert: (input: SandboxAgentUpsertInput) => Promise<import("src/index.js").SandboxAgent>;
+    get: (agentId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxAgent>;
+    update: (agentId: string, input: SandboxAgentUpdateInput) => Promise<import("src/index.js").SandboxAgent>;
+    archive: (agentId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxAgent>;
+    run: (agentId: string, input: SandboxAgentRunInput) => Promise<import("src/index.js").SandboxAgentRunResponse>;
+    sourceDeployPlan: (agentId: string, input: {
+        teamId: string;
+    }) => Promise<import("src/index.js").SandboxAgentSourceDeployPlan>;
+    manifestSnapshots: (agentId: string, input: {
+        teamId: string;
+        limit?: number;
+    }) => Promise<import("src/index.js").SandboxAgentManifestSnapshot[]>;
+    requestSourceChecks: (agentId: string, input: SandboxAgentSourceChecksRequestInput) => Promise<import("src/index.js").SandboxAgentSourceChecksRequestResult>;
+    publishSource: (agentId: string, input: SandboxAgentSourcePublishInput) => Promise<import("src/index.js").SandboxAgentSourcePublishResult>;
+    openEditWorkItem: (agentId: string, input: SandboxAgentEditWorkItemOpenInput) => Promise<import("src/index.js").SandboxAgentEditWorkItemOpenResult>;
+};
+export declare function createSandboxWorkItemNamespace(client: OpenPondSandboxClient): {
+    get: (workItemId: string, input: SandboxCodingWorkItemGetInput) => Promise<import("src/index.js").SandboxCodingWorkItem>;
+    chat: (workItemId: string, input: SandboxCodingWorkItemChatInput) => Promise<import("src/index.js").SandboxCodingWorkItemChatResult>;
+    activity: (workItemId: string, input: SandboxCodingWorkItemActivityListInput) => Promise<import("src/index.js").SandboxCodingWorkItemActivity[]>;
+    status: (workItemId: string, input: SandboxCodingWorkItemActivityListInput & {
+        includeArchived?: boolean;
+    }) => Promise<import("src/index.js").SandboxCodingWorkItemStatusResult>;
+    handleBackground: (workItemId: string, input: SandboxCodingWorkItemBackgroundInput) => Promise<import("src/index.js").SandboxCodingWorkItemBackgroundResult>;
+    promoteCheckpoint: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<import("src/index.js").SandboxCodingWorkItemArtifact>;
+    promoteCommit: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<import("src/index.js").SandboxCodingWorkItemArtifact>;
+    promotePullRequest: (workItemId: string, input: SandboxCodingWorkItemPromotionInput) => Promise<import("src/index.js").SandboxCodingWorkItemArtifact>;
+};