openpond 0.0.30-bootstrap.0

package/dist/chunks/teams-bot-WP3FHKGA.js

@@ -0,0 +1,137 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  resolveSandboxClient
+} from "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import {
+  optionString,
+  parseJsonOption,
+  requiredTeamId
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/teams-bot.ts
+function usage() {
+  return [
+    "usage: teams-bot <overview|bind|rebind|diagnostics|diagnostic-run>",
+    "  teams-bot overview --team-id <id>",
+    "  teams-bot bind --team-id <id> --token <token> [--project-id <id>] [--agent-id <id>] [--microsoft-connection-id <id>]",
+    "  teams-bot rebind <bindingId> --team-id <id> [--project-id <id>] [--agent-id <id>] [--microsoft-connection-id <id>]",
+    "  teams-bot diagnostics <bindingId> --team-id <id>",
+    "  teams-bot diagnostic-run <bindingId> --team-id <id> --prompt <text> [--attachments-json <json-array>] [--action-input-json <json-object>]"
+  ].join("\n");
+}
+function nullableOption(options, key) {
+  if (!(key in options)) return void 0;
+  const value = optionString(options, key);
+  if (!value || value === "null" || value === "none") return null;
+  return value;
+}
+function bindingTargetInput(options) {
+  const teamId = requiredTeamId(options, "usage: teams-bot rebind <bindingId>");
+  const sandboxId = nullableOption(options, "sandboxId");
+  const projectId = nullableOption(options, "projectId");
+  const agentId = nullableOption(options, "agentId");
+  const microsoftConnectionId = nullableOption(options, "microsoftConnectionId");
+  return {
+    teamId,
+    ...sandboxId !== void 0 ? { sandboxId } : {},
+    ...projectId !== void 0 ? { projectId } : {},
+    ...agentId !== void 0 ? { agentId } : {},
+    ...microsoftConnectionId !== void 0 ? { microsoftConnectionId } : {}
+  };
+}
+function attachmentsInput(options) {
+  const raw = optionString(options, "attachmentsJson");
+  if (!raw) return void 0;
+  const parsed = parseJsonOption(raw, "attachments-json");
+  if (!Array.isArray(parsed)) {
+    throw new Error("attachments-json must be a JSON array");
+  }
+  for (const attachment of parsed) {
+    if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) {
+      throw new Error("attachments-json entries must be JSON objects");
+    }
+  }
+  return parsed;
+}
+function actionInput(options) {
+  const raw = optionString(options, "actionInputJson");
+  if (!raw) return void 0;
+  const parsed = parseJsonOption(raw, "action-input-json");
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("action-input-json must be a JSON object");
+  }
+  return parsed;
+}
+async function runTeamsBotCommand(options, rest) {
+  const subcommand = rest[0] || "overview";
+  const client = await resolveSandboxClient(options);
+  if (subcommand === "overview") {
+    const teamId = requiredTeamId(options, "usage: teams-bot overview");
+    console.log(
+      JSON.stringify(await client.getMicrosoftTeamsBotOverview({ teamId }), null, 2)
+    );
+    return;
+  }
+  if (subcommand === "bind") {
+    const token = optionString(options, "token");
+    if (!token) throw new Error(usage());
+    const result = await client.bindMicrosoftTeamsBotConversation({
+      ...bindingTargetInput(options),
+      token
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "rebind") {
+    const bindingId = rest[1]?.trim();
+    if (!bindingId) throw new Error(usage());
+    const result = await client.rebindMicrosoftTeamsBotConversation(
+      bindingId,
+      bindingTargetInput(options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "diagnostics") {
+    const bindingId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: teams-bot diagnostics <bindingId>");
+    if (!bindingId) throw new Error(usage());
+    console.log(
+      JSON.stringify(
+        await client.sendMicrosoftTeamsBotDiagnostic({ teamId, bindingId }),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "diagnostic-run") {
+    const bindingId = rest[1]?.trim();
+    const teamId = requiredTeamId(
+      options,
+      "usage: teams-bot diagnostic-run <bindingId>"
+    );
+    const prompt = optionString(options, "prompt");
+    if (!bindingId || !prompt) throw new Error(usage());
+    console.log(
+      JSON.stringify(
+        await client.sendMicrosoftTeamsBotDiagnosticRun({
+          teamId,
+          bindingId,
+          prompt,
+          attachments: attachmentsInput(options),
+          actionInput: actionInput(options)
+        }),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  throw new Error(usage());
+}
+export {
+  runTeamsBotCommand
+};

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  parseArgs,
+  resolveAccountOption,
+  resolveBaseUrlOption
+} from "./chunks/chunk-5G4E547X.js";
+import {
+  getInstalledCliVersion,
+  parseBooleanOption,
+  runCliCommand
+} from "./chunks/chunk-3Y4EL3P6.js";
+import "./chunks/chunk-UACZUFIA.js";
+
+// src/cli/main.ts
+async function runOpenPondCli(argv = process.argv.slice(2)) {
+  if (await runEmbeddedCompanion(argv)) return;
+  const { command, options, rest } = parseArgs(argv);
+  if (options.version !== void 0 && !command) {
+    console.log(getInstalledCliVersion());
+    return;
+  }
+  if (options.checkUpdate !== void 0) {
+    await (await import("./chunks/core-commands-IM2UKLU4.js")).runCheckUpdate();
+    return;
+  }
+  const selectedAccount = resolveAccountOption(options);
+  const selectedBaseUrl = resolveBaseUrlOption(options);
+  if (selectedAccount) {
+    process.env.OPENPOND_ACCOUNT = selectedAccount;
+  }
+  if (selectedBaseUrl) {
+    process.env.OPENPOND_BASE_URL = selectedBaseUrl;
+  }
+  if (parseBooleanOption(options.tui)) {
+    await (await import("./chunks/app-layer-YKXEQGOW.js")).runOpenPondTerminalCommand(options, rest);
+    return;
+  }
+  if (!command && process.stdin.isTTY && process.stdout.isTTY) {
+    await (await import("./chunks/app-layer-YKXEQGOW.js")).runOpenPondTerminalCommand(options, rest);
+    return;
+  }
+  if (!command) {
+    (await import("./chunks/help-LMH5FGT2.js")).printHelp();
+    return;
+  }
+  if (await runCliCommand({ command, options, rest })) {
+    return;
+  }
+  (await import("./chunks/help-LMH5FGT2.js")).printHelp();
+  process.exit(1);
+}
+async function runEmbeddedCompanion(argv) {
+  if (argv[0] === "__server") {
+    process.argv = [process.execPath, "openpond-server", ...argv.slice(1)];
+    const [{ createOpenPondServer }, { runOpenPondServerCli }] = await Promise.all([
+      import("./chunks/src-EYXQS6XD.js"),
+      import("./chunks/cli-NVKNE4AZ.js")
+    ]);
+    await runOpenPondServerCli(createOpenPondServer);
+    return true;
+  }
+  if (argv[0] === "__terminal") {
+    await (await import("./chunks/src-3RBI4DNN.js")).runOpenPondTerminalCli(argv.slice(1));
+    return true;
+  }
+  return false;
+}
+void runOpenPondCli().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  const exitCode = typeof error.exitCode === "number" ? error.exitCode : 1;
+  process.exit(exitCode);
+});
+export {
+  runOpenPondCli
+};

package/dist/client-types.d.ts

@@ -0,0 +1,222 @@
+import type { StreamCallbacks } from "./stream.js";
+import type { AgentCreateRequest, AppEnvironmentGetResponse, AppEnvironmentUpdateResponse, AppExecutionTimelineResponse, AppListItem, AppRuntimeSummary, AppSchedulesResponse, AssistantMode, AssistantRunResponse, CreateRepoRequest, CreateRepoResponse, DeploymentLogEntry, OpenPondAccountBalanceResponse, OpenPondAccountResponse, OpenPondApiHealth, OpenToolRecipe, OpenToolRecipeGetRequest, OpenToolRecipeListRequest, OpenToolRecipeListResponse, OpenToolRecipeSearchRequest, OpenToolRecipeSearchResponse, OpenToolRulesGetRequest, OpenToolRulesGetResponse, PromotePreviewToProductionRequest, PromotePreviewToProductionResponse, ScheduleDeleteResponse, ScheduleExecutionLog, ScheduleExecutionLogsResponse, ScheduleRunNowRequest, ScheduleRunNowResponse, ScheduleToggleRequest, ScheduleToggleResult, StartAppLifecycleRequest, StartAppLifecycleResponse, TemplateBranchesResponse, TemplateDeployLatestRequest, TemplateDeployLatestResponse, TemplateStatusResponse, ToolExecuteRequest, ToolExecuteResponse } from "./api.js";
+export type OpenPondClientOptions = {
+    apiKey?: string;
+    baseUrl?: string;
+    apiUrl?: string;
+    chatApiUrl?: string;
+    opChatApiUrl?: string;
+    toolUrl?: string;
+    cacheTtlMs?: number;
+    useCache?: boolean;
+};
+export type ToolSummary = {
+    name: string;
+    description?: string;
+    raw: unknown;
+};
+export type ToolListResult = {
+    app: AppListItem;
+    deploymentId: string | null;
+    tools: ToolSummary[];
+};
+export type DeploymentWatchResult = {
+    deploymentId: string;
+    status: string | "timeout" | null;
+    logs: DeploymentLogEntry[];
+};
+export type AgentCreateStreamCallbacks = StreamCallbacks & {
+    onAppId?: (appId: string) => void;
+    onDeploymentId?: (deploymentId: string) => void;
+};
+export type AgentCreateStreamResult = {
+    conversationId?: string;
+    appId?: string;
+    deploymentId?: string;
+};
+export type OpenPondClient = {
+    baseUrl: string;
+    apiUrl: string;
+    chatApiUrl: string;
+    toolUrl: string;
+    apiKey: string;
+    account: {
+        get: () => Promise<OpenPondAccountResponse>;
+        balance: () => Promise<OpenPondAccountBalanceResponse>;
+        health: () => Promise<OpenPondApiHealth>;
+    };
+    chat: {
+        providers: () => Promise<import("./hosted-chat.js").HostedProvidersResponse>;
+        provider: (provider: string) => Promise<import("./hosted-chat.js").HostedProvider>;
+        models: () => Promise<import("./hosted-chat.js").HostedModelsResponse>;
+        model: (model: string) => Promise<import("./hosted-chat.js").HostedModel>;
+        send: (input: Omit<import("./hosted-chat.js").HostedChatRequestOptions, "apiBaseUrl" | "token">) => Promise<import("./hosted-chat.js").HostedChatCompletion>;
+        stream: (input: Omit<import("./hosted-chat.js").HostedChatRequestOptions, "apiBaseUrl" | "token">) => AsyncGenerator<import("./hosted-chat.js").HostedChatStreamDelta, void, unknown>;
+    };
+    tool: {
+        list: (target: string, options?: ToolListOptions) => Promise<ToolListResult>;
+        run: (target: string, toolName: string, options?: ToolRunOptions) => Promise<ToolExecuteResponse>;
+    };
+    deploy: {
+        watch: (target: string, options?: DeployWatchOptions) => Promise<DeploymentWatchResult>;
+    };
+    template: {
+        status: (target: string, options?: TemplateTargetOptions) => Promise<TemplateStatusResponse>;
+        branches: (target: string, options?: TemplateTargetOptions) => Promise<TemplateBranchesResponse>;
+        update: (target: string, options?: TemplateUpdateOptions) => Promise<TemplateDeployLatestResponse>;
+    };
+    opentool: {
+        recipesList: (input?: OpenToolRecipeListRequest) => Promise<OpenToolRecipeListResponse>;
+        recipesSearch: (input: OpenToolRecipeSearchRequest) => Promise<OpenToolRecipeSearchResponse>;
+        recipeGet: (input: OpenToolRecipeGetRequest) => Promise<OpenToolRecipe>;
+        rulesGet: (input: OpenToolRulesGetRequest) => Promise<OpenToolRulesGetResponse>;
+    };
+    apps: {
+        list: (options?: AppsListOptions) => Promise<AppListItem[]>;
+        tools: (options?: AppsToolsOptions) => Promise<unknown[]>;
+        performance: (options?: AppsPerformanceOptions) => Promise<unknown>;
+        summary: (input: AppSummaryOptions) => Promise<AppRuntimeSummary>;
+        schedules: (input: AppSchedulesOptions) => Promise<AppSchedulesResponse>;
+        schedulesStart: (input: AppSchedulesStartOptions) => Promise<ScheduleToggleResult>;
+        schedulesStop: (input: AppSchedulesStopOptions) => Promise<ScheduleToggleResult>;
+        schedulesStopCurrent: () => Promise<ScheduleToggleResult>;
+        scheduleRunNow: (input: ScheduleRunNowOptions) => Promise<ScheduleRunNowResponse>;
+        scheduleDelete: (input: ScheduleDeleteOptions) => Promise<ScheduleDeleteResponse>;
+        scheduleExecutionLogs: (input: ScheduleExecutionLogsOptions) => Promise<ScheduleExecutionLogsResponse>;
+        scheduleExecutionLog: (input: ScheduleExecutionLogOptions) => Promise<ScheduleExecutionLog>;
+        deploymentScheduleExecutionLogs: (input: DeploymentScheduleExecutionLogsOptions) => Promise<ScheduleExecutionLogsResponse>;
+        executionTimeline: (input: AppExecutionTimelineOptions) => Promise<AppExecutionTimelineResponse>;
+        assistantRun: (input: AppsAssistantRunOptions) => Promise<AssistantRunResponse>;
+        agentCreate: (input: AgentCreateRequest & {
+            refreshCache?: boolean;
+        }, callbacks?: AgentCreateStreamCallbacks) => Promise<AgentCreateStreamResult>;
+        toolsExecute: (input: ExecuteUserToolOptions) => Promise<ToolExecuteResponse>;
+        deploy: (input: AppDeployOptions) => Promise<{
+            deploymentId: string;
+        }>;
+        startApp: (input: AppStartOptions) => Promise<StartAppLifecycleResponse>;
+        promotePreview: (input: AppPromotePreviewOptions) => Promise<PromotePreviewToProductionResponse>;
+        envGet: (input: AppEnvironmentGetOptions) => Promise<AppEnvironmentGetResponse>;
+        envSet: (input: AppEnvironmentSetOptions) => Promise<AppEnvironmentUpdateResponse>;
+        positionsTx: (input?: PositionsTxOptions) => Promise<unknown>;
+    };
+    repo: {
+        create: (input: CreateRepoRequest & {
+            refreshCache?: boolean;
+        }) => Promise<CreateRepoResponse>;
+    };
+    cache: {
+        refresh: () => Promise<void>;
+    };
+};
+export type ToolListOptions = {
+    branch?: string;
+    forceRefresh?: boolean;
+    deploymentId?: string;
+};
+export type ToolRunOptions = {
+    branch?: string;
+    deploymentId?: string;
+    method?: ToolExecuteRequest["method"];
+    body?: unknown;
+    headers?: Record<string, string>;
+    forceRefresh?: boolean;
+};
+export type DeployWatchOptions = {
+    branch?: string;
+    deploymentId?: string;
+    intervalMs?: number;
+    timeoutMs?: number;
+    forceRefresh?: boolean;
+    onLog?: (log: DeploymentLogEntry) => void;
+    onStatus?: (status: string | null) => void;
+};
+export type TemplateTargetOptions = {
+    forceRefresh?: boolean;
+};
+export type TemplateUpdateOptions = {
+    environment?: TemplateDeployLatestRequest["environment"];
+    forceRefresh?: boolean;
+};
+export type AppsListOptions = {
+    handle?: string;
+    forceRefresh?: boolean;
+};
+export type AppsToolsOptions = {
+    forceRefresh?: boolean;
+};
+export type AppsPerformanceOptions = {
+    appId?: string;
+};
+export type AppSummaryOptions = {
+    appId: string;
+};
+export type AppSchedulesOptions = {
+    appId: string;
+};
+export type AppSchedulesStartOptions = {
+    appId: string;
+} & ScheduleToggleRequest;
+export type AppSchedulesStopOptions = {
+    appId: string;
+};
+export type ScheduleRunNowOptions = ScheduleRunNowRequest;
+export type ScheduleDeleteOptions = {
+    appId: string;
+    scheduleId: string;
+};
+export type ScheduleExecutionLogsOptions = {
+    scheduleId: string;
+    limit?: number;
+};
+export type ScheduleExecutionLogOptions = {
+    runId: string;
+};
+export type DeploymentScheduleExecutionLogsOptions = {
+    deploymentId: string;
+    limit?: number;
+};
+export type AppExecutionTimelineOptions = {
+    appId: string;
+    limit?: number;
+};
+export type AppsAssistantRunOptions = {
+    appId: string;
+    mode: AssistantMode;
+    prompt: string;
+};
+export type ExecuteUserToolOptions = {
+    appId: string;
+    deploymentId: string;
+    toolName: string;
+    scheduleId?: string;
+    method?: ToolExecuteRequest["method"];
+    body?: unknown;
+    headers?: Record<string, string>;
+    notifyEmail?: boolean;
+};
+export type AppEnvironmentSetOptions = {
+    appId: string;
+    envVars: Record<string, string>;
+};
+export type AppEnvironmentGetOptions = {
+    appId: string;
+};
+export type AppDeployOptions = {
+    appId: string;
+    environment?: "preview" | "production";
+    commitSha?: string;
+    branch?: string;
+};
+export type AppPromotePreviewOptions = {
+    appId: string;
+} & PromotePreviewToProductionRequest;
+export type AppStartOptions = {
+    appId: string;
+} & StartAppLifecycleRequest;
+export type PositionsTxOptions = {
+    method?: "GET" | "POST";
+    body?: unknown;
+    params?: Record<string, unknown>;
+    query?: Record<string, string>;
+};

package/dist/client.d.ts

@@ -0,0 +1,19 @@
+export type { StreamCallbacks } from "./stream.js";
+export type { AssistantMode, AssistantRunResponse, AgentCreateRequest, AppEnvironmentGetResponse, AppEnvironmentUpdateRequest, AppEnvironmentUpdateResponse, AppExecutionDeployment, AppExecutionTimelineResponse, AppExecutionToolRun, AppListItem, AppRuntimeSummary, AppSchedule, AppScheduleSummary, AppSchedulesResponse, CreateRepoRequest, CreateRepoResponse, DeploymentDetail, DeploymentLogEntry, OpenPondAccount, OpenPondAccountBalanceResponse, OpenPondAccountProduct, OpenPondAccountResponse, OpenPondApiHealth, OpenPondApiHealthResponse, OpenToolRecipe, OpenToolRecipeDomain, OpenToolRecipeGetRequest, OpenToolRecipeListRequest, OpenToolRecipeListResponse, OpenToolRecipeSearchRequest, OpenToolRecipeSearchResponse, OpenToolRecipeSummary, OpenToolRulesGetRequest, OpenToolRulesGetResponse, PromotePreviewToProductionRequest, PromotePreviewToProductionResponse, ScheduleDeleteResponse, ScheduleExecutionLog, ScheduleExecutionLogsResponse, ScheduleRunNowRequest, ScheduleRunNowResponse, ScheduleToggleRequest, ScheduleToggleResult, StartAppLifecycleRequest, StartAppLifecycleResponse, TemplateBranchesResponse, TemplateDeployLatestRequest, TemplateDeployLatestResponse, TemplateStatusResponse, ToolExecuteRequest, ToolExecuteResponse, } from "./api.js";
+export type { ChatRequestBody, ResponseItem, ResponseMessageItem, TemplateBootstrap, ToolCallItem, ToolOutputItem, UsageInfo, } from "./types.js";
+export type { HostedChatCompletion, HostedChatContinuation, HostedChatMessage, HostedChatRequestOptions, HostedChatRole, HostedChatStreamDelta, HostedChatTool, HostedChatToolCall, HostedChatToolChoice, HostedChatUsage, HostedChatApiBaseUrlOptions, HostedModel, HostedModelRequestOptions, HostedModelsRequestOptions, HostedModelsResponse, HostedProvider, HostedProviderRequestOptions, HostedProvidersRequestOptions, HostedProvidersResponse, } from "./hosted-chat.js";
+export type { OpChatCompletionSummary, OpChatSmokeOptions, OpChatSmokeSummary, OpChatStreamSummary, OpChatToolSummary, } from "./opchat-smoke.js";
+export type { Bar as IndicatorBar, BollingerResult, MacdResult, MaCrossResult, MaCrossSignal, PriceChangeResult, } from "./indicators.js";
+export { apiFetch, checkOpenPondApiHealth, getAppRuntimeSummary, commitFiles, createAgentFromPrompt, createRepo, createHeadlessApps, createLocalProject, deleteOrArchiveSchedule, deployApp, deployLatestTemplate, getAppEnvironment, getAppExecutionTimeline, getScheduleExecutionLog, updateAppEnvironment, executeHostedTool, executeUserTool, fetchToolManifest, getDeploymentDetail, getDeploymentLogs, getDeploymentStatus, getLatestDeploymentForApp, getOpenPondAccount, getOpenPondAccountBalance, getOpenToolRecipe, getOpenToolRules, getTemplateStatus, getUserPerformance, runAssistantMode, listApps, listAppSchedules, listDeploymentScheduleExecutionLogs, listOpenToolRecipes, listScheduleExecutionLogs, listTemplateBranches, listUserTools, postAgentDigest, promotePreviewToProduction, resolveWorkerBaseUrl, runScheduleNow, searchOpenToolRecipes, startAppLifecycle, startAppSchedules, stopAppSchedules, stopCurrentAppSchedules, submitPositionsTx, } from "./api.js";
+export { DEFAULT_OPENPOND_API_BASE_URL, DEFAULT_OPENPOND_CHAT_API_BASE_URL, DEFAULT_OPENPOND_OPCHAT_API_BASE_URL, DEFAULT_OPENPOND_WEB_BASE_URL, } from "./urls.js";
+export { getOpChatModel, getOpChatProvider, listOpChatModels, listOpChatProviders, listHostedModels, listHostedProviders, resolveHostedChatApiBaseUrl, resolveOpChatApiBaseUrl, sendHostedChatTurn, streamHostedChatTurn, } from "./hosted-chat.js";
+export { runOpChatSmoke } from "./opchat-smoke.js";
+export { computeAtr, computeBollinger, computeEma, computeEmaSeries, computeMacd, computeMaCross, computePriceChange, computeRsi, computeSma, computeSmaSeries, } from "./indicators.js";
+export { DEFAULT_CACHE_TTL_MS, getCachedApps, getCachedTools, setCachedApps, setCachedTools, } from "./cache.js";
+export { getConfigPath, listConfiguredProfiles, loadConfig, loadGlobalConfig, saveConfig, saveGlobalConfig, saveProfileApiKey, setActiveProfile, } from "./config.js";
+export type { ActiveProfileSelector, ConfiguredProfile, LocalConfig, SaveProfileApiKeyInput, SetActiveProfileOptions, } from "./config.js";
+export { consumeStream, formatStreamItem, normalizeDataFrames } from "./stream.js";
+export type { OpenPondClientOptions, ToolSummary, ToolListResult, DeploymentWatchResult, AgentCreateStreamCallbacks, AgentCreateStreamResult, OpenPondClient, ToolListOptions, ToolRunOptions, DeployWatchOptions, TemplateTargetOptions, TemplateUpdateOptions, AppsListOptions, AppsToolsOptions, AppsPerformanceOptions, AppSummaryOptions, AppSchedulesOptions, AppSchedulesStartOptions, AppSchedulesStopOptions, ScheduleRunNowOptions, ScheduleDeleteOptions, ScheduleExecutionLogsOptions, ScheduleExecutionLogOptions, DeploymentScheduleExecutionLogsOptions, AppExecutionTimelineOptions, AppsAssistantRunOptions, ExecuteUserToolOptions, AppEnvironmentSetOptions, AppEnvironmentGetOptions, AppDeployOptions, AppPromotePreviewOptions, AppStartOptions, PositionsTxOptions, } from "./client-types.js";
+import type { OpenPondClientOptions, AgentCreateStreamCallbacks, AgentCreateStreamResult, OpenPondClient } from "./client-types.js";
+export declare function consumeAgentCreateStream(response: Response, callbacks?: AgentCreateStreamCallbacks): Promise<AgentCreateStreamResult>;
+export declare function createClient(options: OpenPondClientOptions): OpenPondClient;

package/dist/config.d.ts

@@ -0,0 +1,184 @@
+export type LocalSessionConfig = {
+    token?: string;
+    appId?: string | null;
+    conversationId?: string | null;
+};
+export type LocalAccountConfig = {
+    handle: string;
+    apiKey?: string;
+    baseUrl?: string;
+    apiBaseUrl?: string;
+    chatApiBaseUrl?: string;
+    environment?: string;
+    session?: LocalSessionConfig;
+};
+export type ActiveProfileSelector = {
+    handle: string;
+    baseUrl?: string | null;
+};
+export type LocalOpenPondProfileCheckStatus = {
+    command: "inspect" | "build" | "validate" | "eval" | "run";
+    status: "passed" | "failed";
+    checkedAt: string;
+    exitCode?: number | null;
+    sourceHead?: string | null;
+};
+export type LocalOpenPondProfileHostedSourceCheckStatus = {
+    status: string;
+    agentId?: string | null;
+    workItemId?: string | null;
+    deployPlanStatus?: string | null;
+    canRun?: boolean | null;
+    canDeploy?: boolean | null;
+    sourceRef?: string | null;
+    sourceCommitSha?: string | null;
+    manifestHash?: string | null;
+    manifestPath?: string | null;
+    setupCommands?: string[];
+    validationCommands?: string[];
+    requiredChecks?: string[];
+    evalNames?: string[];
+    blockedReasons?: string[];
+    staleReasons?: string[];
+    runtimeId?: string | null;
+    sandboxId?: string | null;
+    traceArtifactRefs?: string[];
+    evalResultArtifactRefs?: string[];
+    validatorArtifactRefs?: string[];
+    checkedAt?: string | null;
+    error?: string | null;
+};
+export type LocalOpenPondProfileHostedMaterializationStatus = {
+    status: string;
+    agentId?: string | null;
+    runtimeAgentId?: string | null;
+    projectId?: string | null;
+    sourceRoot?: string | null;
+    sourceRef?: string | null;
+    sourceCommitSha?: string | null;
+    manifestHash?: string | null;
+    manifestPath?: string | null;
+    manifestSyncedAt?: string | null;
+    fileCount?: number | null;
+    totalBytes?: number | null;
+    generatedManifestPath?: string | null;
+    synthesizedOpenPondYaml?: boolean | null;
+    uploadMetadataPath?: string | null;
+    setupCommands?: string[];
+    validationCommands?: string[];
+    materializedAt?: string | null;
+    error?: string | null;
+};
+export type LocalOpenPondProfileHostedPublishStatus = {
+    status: string;
+    agentId?: string | null;
+    snapshotId?: string | null;
+    sourceRef?: string | null;
+    sourceCommitSha?: string | null;
+    manifestHash?: string | null;
+    manifestPath?: string | null;
+    buildStatus?: string | null;
+    validationStatus?: string | null;
+    evalStatus?: string | null;
+    publishedAt?: string | null;
+    error?: string | null;
+};
+export type LocalOpenPondProfileHostedRunSummary = {
+    status: string;
+    agentId?: string | null;
+    runId?: string | null;
+    runtimeId?: string | null;
+    sandboxId?: string | null;
+    sourceRef?: string | null;
+    sourceCommitSha?: string | null;
+    manifestHash?: string | null;
+    setupGateStatus?: string | null;
+    setupRequirementRefs?: string[];
+    artifactRefs?: string[];
+    traceArtifactRefs?: string[];
+    evalArtifactRefs?: string[];
+    startedAt?: string | null;
+    completedAt?: string | null;
+    error?: string | null;
+};
+export type LocalOpenPondProfilePushStatus = {
+    status: "pushed" | "failed";
+    promotionStatus?: "uploaded" | "hosted_source_materialized" | "hosted_source_materialize_failed" | "hosted_source_check_pending" | "hosted_source_check_failed" | "hosted_source_published" | "hosted_source_publish_failed" | "hosted_run_pending" | "hosted_run_passed" | "hosted_run_failed" | null;
+    hostedRunStatus?: "not_started" | "running" | "passed" | "failed" | null;
+    pushedAt: string;
+    teamId?: string | null;
+    projectId?: string | null;
+    localHead?: string | null;
+    hostedHead?: string | null;
+    sourceRef?: 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;
+    error?: string | null;
+};
+export type LocalOpenPondProfileConfig = {
+    repoPath: string;
+    profile: string;
+    mode: "local";
+    lastCheck?: LocalOpenPondProfileCheckStatus;
+    lastPush?: LocalOpenPondProfilePushStatus;
+};
+export type LocalGoalStorageLocation = "global" | "workspace";
+export type LocalConfig = {
+    accounts?: LocalAccountConfig[];
+    activeProfile?: ActiveProfileSelector;
+    openpondProfile?: LocalOpenPondProfileConfig;
+    goalStorageLocation?: LocalGoalStorageLocation;
+    baseUrl?: string;
+    apiBaseUrl?: string;
+    chatApiBaseUrl?: string;
+    apiKey?: string;
+    token?: string;
+    appId?: string | null;
+    conversationId?: string | null;
+    lspEnabled?: boolean;
+    executionMode?: "local" | "hosted";
+    mode?: "general" | "builder";
+};
+export type ConfiguredProfile = {
+    handle: string;
+    baseUrl: string | null;
+    apiBaseUrl: string | null;
+    chatApiBaseUrl: string | null;
+    environment: string | null;
+    isActive: boolean;
+    hasApiKey: boolean;
+    hasSessionToken: boolean;
+    sessionAppId: string | null;
+    sessionConversationId: string | null;
+};
+export type SetActiveProfileOptions = {
+    baseUrl?: string | null;
+};
+export type SaveProfileApiKeyInput = {
+    handle: string;
+    apiKey: string;
+    baseUrl?: string | null;
+    apiBaseUrl?: string | null;
+    chatApiBaseUrl?: string | null;
+    environment?: string | null;
+    setActive?: boolean;
+};
+export type LoadConfigOptions = {
+    account?: string;
+    baseUrl?: string;
+};
+export declare function getConfigPath(): string;
+export declare function loadGlobalConfig(): Promise<LocalConfig>;
+export declare function loadConfig(options?: LoadConfigOptions): Promise<LocalConfig>;
+export declare function listConfiguredProfiles(): Promise<ConfiguredProfile[]>;
+export declare function setActiveProfile(handle: string, options?: SetActiveProfileOptions): Promise<ConfiguredProfile>;
+export declare function saveProfileApiKey(input: SaveProfileApiKeyInput): Promise<ConfiguredProfile>;
+export declare function saveConfig(next: LocalConfig): Promise<void>;
+export declare function saveGlobalConfig(next: LocalConfig): Promise<void>;