@thisispandora/agent-sdk 0.1.0-alpha.1

package/generated/mcp-tool-definitions.mjs

@@ -0,0 +1,3 @@
+import generated from './index.js';
+export const mcpToolDefinitions = generated.mcpToolDefinitions;
+export default generated.mcpToolDefinitions;

package/index.d.ts

@@ -0,0 +1,401 @@
+export interface PandoraRootPublishedSurface {
+  artifactSubpaths: {
+    bundle: string;
+    commandDescriptors: string;
+    entrypoint: string;
+    manifest: string;
+    mcpToolDefinitions: string;
+    types: string;
+  };
+  binNames: string[];
+  exportSubpaths: string[];
+  format: 'node';
+  main: string | null;
+  name: string;
+  sourceProjectPath: string;
+  version: string;
+}
+
+export interface PandoraTypescriptPublishedSurface {
+  artifactSubpaths: {
+    bundle: string;
+    commandDescriptors: string;
+    entrypoint: string;
+    manifest: string;
+    mcpToolDefinitions: string;
+    types: string;
+  };
+  exportSubpaths: string[];
+  format: 'node';
+  name: string;
+  sourceProjectPath: string;
+  version: string;
+}
+
+export interface PandoraPythonPublishedSurface {
+  artifactSubpaths: {
+    bundle: string;
+    commandDescriptors: string;
+    manifest: string;
+    mcpToolDefinitions: string;
+  };
+  format: 'python';
+  module: 'pandora_agent';
+  name: string;
+  sourceProjectPath: string;
+  version: string;
+}
+
+export interface PandoraPublishedSurfaces {
+  root: PandoraRootPublishedSurface;
+  typescript: PandoraTypescriptPublishedSurface;
+  python: PandoraPythonPublishedSurface;
+}
+
+export interface PandoraGeneratedManifest {
+  artifactVersion: string;
+  schemaVersion: string | number;
+  packageVersion: string;
+  contractVersion?: string | null;
+  contractPackageVersion?: string | null;
+  contractCommandDescriptorVersion?: string | null;
+  generatedFrom: string;
+  generator: string;
+  commandDescriptorVersion: string;
+  commandCount: number;
+  mcpToolCount: number;
+  registryDigest?: Record<string, string>;
+  catalogSummary?: Record<string, unknown>;
+  backends?: Record<string, unknown>;
+  package?: PandoraRootPublishedSurface | PandoraTypescriptPublishedSurface | PandoraPythonPublishedSurface;
+  publishedSurfaces?: PandoraPublishedSurfaces;
+  artifacts: Record<string, string>;
+}
+
+export interface PandoraGeneratedMcpToolDefinition {
+  name: string;
+  command: string[];
+  description: string;
+  inputSchema: Record<string, unknown>;
+  xPandora?: PandoraCommandDescriptor | Record<string, unknown> | null;
+  mutating?: boolean;
+  safeFlags?: string[];
+  executeFlags?: string[];
+  longRunningBlocked?: boolean;
+  placeholderBlocked?: boolean;
+  aliasOf?: string | null;
+  canonicalTool?: string | null;
+  preferred?: boolean;
+  controlInputNames?: string[];
+  agentWorkflow?: Record<string, unknown> | null;
+  supportsRemote?: boolean;
+  remoteEligible?: boolean;
+  policyScopes?: string[];
+  canonicalCommandTokens?: string[];
+  canonicalUsage?: string | null;
+  metadataProvenance?: string | null;
+}
+
+export interface PandoraCommandDescriptor {
+  aliasOf?: string | null;
+  canonicalCommandTokens?: string[] | null;
+  canonicalTool?: string | null;
+  canonicalUsage?: string | null;
+  canRunConcurrent?: boolean;
+  controlInputNames?: string[];
+  dataSchema?: string | null;
+  emits?: string[];
+  executeFlags?: string[];
+  executeIntentRequired?: boolean;
+  executeIntentRequiredForLiveMode?: boolean;
+  expectedLatencyMs?: number | null;
+  externalDependencies?: string[];
+  helpDataSchema?: string | null;
+  idempotency?: string;
+  inputSchema?: Record<string, unknown> | null;
+  jobCapable?: boolean;
+  mcpExposed?: boolean;
+  mcpLongRunningBlocked?: boolean;
+  mcpMutating?: boolean;
+  outputModes?: string[];
+  policyScopes?: string[];
+  preferred?: boolean;
+  recommendedPreflightTool?: string | null;
+  remoteEligible?: boolean;
+  requiresSecrets?: boolean;
+  returnsOperationId?: boolean;
+  returnsRuntimeHandle?: boolean;
+  riskLevel?: string;
+  safeEquivalent?: string | null;
+  safeFlags?: string[];
+  summary?: string;
+  supportsRemote?: boolean;
+  supportsWebhook?: boolean;
+  usage?: string;
+  [key: string]: unknown;
+}
+
+export interface PandoraCapabilityFeature {
+  supported: boolean;
+  status: string;
+  notes: string[];
+  [key: string]: unknown;
+}
+
+export interface PandoraPolicyPackCapability extends PandoraCapabilityFeature {
+  commandsWithPolicyScopes?: string[];
+  policyScopedCommandCount?: number;
+  samplePolicyScopedCommands?: string[];
+  builtinIds?: string[];
+  userCount?: number;
+  userSampleIds?: string[];
+}
+
+export interface PandoraSignerProfileCapability extends PandoraCapabilityFeature {
+  commandsRequiringSecrets?: string[];
+  secretBearingCommandCount?: number;
+  sampleSecretBearingCommands?: string[];
+  builtinIds?: string[];
+  signerBackends?: string[];
+  implementedBackends?: string[];
+  placeholderBackends?: string[];
+  readyBuiltinIds?: string[];
+  pendingBuiltinIds?: string[];
+  degradedBuiltinIds?: string[];
+  placeholderBuiltinIds?: string[];
+  readyBuiltinCount?: number;
+  pendingBuiltinCount?: number;
+  degradedBuiltinCount?: number;
+  placeholderBuiltinCount?: number;
+  backendStatuses?: Record<string, unknown>;
+  statusAxes?: Record<string, unknown>;
+}
+
+export interface PandoraPolicyProfileCapabilities {
+  policyPacks: PandoraPolicyPackCapability;
+  signerProfiles: PandoraSignerProfileCapability;
+}
+
+export interface PandoraToolPolicySurface {
+  name: string;
+  canonicalTool: string;
+  aliasOf: string | null;
+  preferred: boolean;
+  policyScopes: string[];
+  requiresSecrets: boolean;
+  policyPackEligible: boolean;
+  signerProfileEligible: boolean;
+  supportsRemote: boolean;
+  remoteEligible: boolean;
+  policyPackStatus: string;
+  signerProfileStatus: string;
+}
+
+export interface PandoraPolicyScopeInspection {
+  scope: string;
+  commands: string[];
+  tools: PandoraToolPolicySurface[];
+}
+
+export interface PandoraToolContract {
+  name: string;
+  description: string | null;
+  inputSchema: Record<string, unknown>;
+  xPandora?: Record<string, unknown> | null;
+  commandDescriptor?: PandoraCommandDescriptor | null;
+}
+
+export interface PandoraRuntimeToolDefinition {
+  name: string;
+  description: string | null;
+  inputSchema: Record<string, unknown>;
+  xPandora?: PandoraCommandDescriptor | Record<string, unknown> | null;
+  commandDescriptor?: PandoraCommandDescriptor | null;
+  policyScopes: string[];
+  requiresSecrets: boolean;
+  supportsRemote: boolean;
+  remoteEligible: boolean;
+  canonicalTool: string | null;
+  aliasOf: string | null;
+  preferred: boolean;
+  [key: string]: unknown;
+}
+
+export interface PandoraCompatibilityCatalogSummary {
+  mode: 'compatibility-aliases';
+  commandCount: number;
+  mcpToolCount: number;
+  commandNames: string[];
+  toolNames: string[];
+}
+
+export interface PandoraCompatibilityCatalog {
+  mode: 'explicit';
+  commandDescriptors: Record<string, PandoraCommandDescriptor>;
+  mcpToolDefinitions: PandoraGeneratedMcpToolDefinition[];
+  tools: Record<string, PandoraToolContract>;
+  summary: PandoraCompatibilityCatalogSummary;
+}
+
+export interface PandoraContractRegistry {
+  artifactVersion?: string;
+  schemaVersion: string;
+  packageVersion: string;
+  commandDescriptorVersion: string;
+  summary: Record<string, unknown>;
+  backends?: Record<string, unknown>;
+  registryDigest?: Record<string, string>;
+  tools: Record<string, PandoraToolContract>;
+  commandDescriptors?: Record<string, PandoraCommandDescriptor>;
+  compatibility?: PandoraCompatibilityCatalog;
+  schemas: {
+    envelope: Record<string, unknown>;
+    definitions: Record<string, unknown>;
+  };
+  capabilities: {
+    schemaVersion: string;
+    commandDescriptorVersion: string;
+    transports: Record<string, unknown>;
+    commandDigests: Record<string, PandoraCommandDescriptor>;
+    registryDigest: Record<string, string>;
+    policyProfiles?: PandoraPolicyProfileCapabilities;
+    [key: string]: unknown;
+  };
+}
+
+export interface PandoraCallToolRawResult {
+  content?: Array<{ type?: string; text?: string }>;
+  structuredContent?: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export interface PandoraSdkErrorDetails {
+  cause?: unknown;
+  [key: string]: unknown;
+}
+
+export declare class PandoraSdkError extends Error {
+  code: string;
+  details?: PandoraSdkErrorDetails;
+  cause?: unknown;
+  constructor(code: string, message: string, details?: PandoraSdkErrorDetails);
+}
+
+export declare class PandoraToolCallError extends PandoraSdkError {
+  sdkCode: string;
+  envelope: Record<string, unknown> | null;
+  rawResult: PandoraCallToolRawResult | null;
+  toolName: string | null;
+  toolError: Record<string, unknown> | null;
+  constructor(message: string, details?: PandoraSdkErrorDetails);
+}
+
+export interface PandoraStdioBackendOptions {
+  command?: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  stderr?: 'pipe' | 'inherit' | 'overlapped';
+  clientName?: string;
+  clientVersion?: string;
+}
+
+export interface PandoraRemoteBackendOptions {
+  url: string | URL;
+  authToken?: string;
+  headers?: Record<string, string>;
+  fetch?: typeof fetch;
+  clientName?: string;
+  clientVersion?: string;
+}
+
+export interface PandoraAgentClientFactoryOptions extends PandoraStdioBackendOptions {
+  backend?: PandoraMcpBackend;
+  catalog?: PandoraContractRegistry;
+  mode?: 'local' | 'remote';
+  url?: string | URL;
+  authToken?: string;
+  headers?: Record<string, string>;
+  fetch?: typeof fetch;
+}
+
+export interface PandoraGeneratedCatalogModule {
+  manifest: PandoraGeneratedManifest;
+  commandDescriptors: Record<string, PandoraCommandDescriptor>;
+  mcpToolDefinitions: PandoraGeneratedMcpToolDefinition[];
+  contractRegistry: PandoraContractRegistry;
+  loadGeneratedManifest(): PandoraGeneratedManifest;
+  loadGeneratedCommandDescriptors(): Record<string, PandoraCommandDescriptor>;
+  loadGeneratedMcpToolDefinitions(): PandoraGeneratedMcpToolDefinition[];
+  loadGeneratedContractRegistry(): PandoraContractRegistry;
+  loadGeneratedCapabilities(): PandoraContractRegistry['capabilities'];
+  loadGeneratedToolCatalog(): PandoraContractRegistry['tools'];
+}
+
+export declare class PandoraMcpBackend {
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  listTools(): Promise<PandoraRuntimeToolDefinition[] | Array<Record<string, unknown>>>;
+  callTool(name: string, args?: Record<string, unknown>): Promise<PandoraCallToolRawResult>;
+}
+
+export declare class PandoraStdioBackend extends PandoraMcpBackend {
+  constructor(options?: PandoraStdioBackendOptions);
+}
+
+export declare class PandoraRemoteBackend extends PandoraMcpBackend {
+  constructor(options: PandoraRemoteBackendOptions);
+}
+
+export declare class PandoraAgentClient {
+  constructor(options: { backend: PandoraMcpBackend; catalog?: PandoraContractRegistry });
+  connect(): Promise<this>;
+  close(): Promise<void>;
+  getManifest(): PandoraGeneratedManifest;
+  getCatalog(): PandoraContractRegistry;
+  getPolicyProfileCapabilities(): PandoraPolicyProfileCapabilities;
+  getPolicyPackCapability(): PandoraPolicyPackCapability;
+  getSignerProfileCapability(): PandoraSignerProfileCapability;
+  listPolicyScopes(): string[];
+  listPolicyScopedCommands(): string[];
+  listSignerProfileCommands(): string[];
+  inspectPolicyScope(scope: string): PandoraPolicyScopeInspection;
+  inspectToolPolicySurface(name: string): PandoraToolPolicySurface;
+  listGeneratedTools(): string[];
+  getTool(name: string): PandoraToolContract | null;
+  requireTool(name: string): PandoraToolContract;
+  listTools(): Promise<PandoraRuntimeToolDefinition[]>;
+  callToolRaw(name: string, args?: Record<string, unknown>): Promise<PandoraCallToolRawResult>;
+  callToolEnvelope(name: string, args?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  callToolData(name: string, args?: Record<string, unknown>): Promise<unknown>;
+  getBootstrapEnvelope(args?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  getBootstrap(args?: Record<string, unknown>): Promise<unknown>;
+  callTool(name: string, args?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+export declare function loadGeneratedContractRegistry(): PandoraContractRegistry;
+export declare function loadGeneratedManifest(): PandoraGeneratedManifest;
+export declare function loadGeneratedCommandDescriptors(): Record<string, PandoraCommandDescriptor>;
+export declare function loadGeneratedMcpToolDefinitions(): PandoraGeneratedMcpToolDefinition[];
+export declare function loadGeneratedCapabilities(): PandoraContractRegistry['capabilities'];
+export declare function loadGeneratedToolCatalog(): PandoraContractRegistry['tools'];
+export declare function normalizeStructuredEnvelope(result: PandoraCallToolRawResult): Record<string, unknown>;
+export declare function normalizeRuntimeToolDefinition(
+  tool: Record<string, unknown>,
+  catalog?: PandoraContractRegistry,
+): PandoraRuntimeToolDefinition;
+export declare function getPolicyProfileCapabilities(catalog?: PandoraContractRegistry): PandoraPolicyProfileCapabilities;
+export declare function getPolicyPackCapability(catalog?: PandoraContractRegistry): PandoraPolicyPackCapability;
+export declare function getSignerProfileCapability(catalog?: PandoraContractRegistry): PandoraSignerProfileCapability;
+export declare function listPolicyScopes(catalog?: PandoraContractRegistry): string[];
+export declare function listPolicyScopedCommands(catalog?: PandoraContractRegistry): string[];
+export declare function listSignerProfileCommands(catalog?: PandoraContractRegistry): string[];
+export declare function inspectPolicyScope(scope: string, catalog?: PandoraContractRegistry): PandoraPolicyScopeInspection;
+export declare function inspectToolPolicySurface(name: string, catalog?: PandoraContractRegistry): PandoraToolPolicySurface;
+export declare function createPandoraStdioBackend(options?: PandoraStdioBackendOptions): PandoraStdioBackend;
+export declare function createPandoraRemoteBackend(options: PandoraRemoteBackendOptions): PandoraRemoteBackend;
+export declare function createLocalPandoraAgentClient(options?: PandoraStdioBackendOptions & { catalog?: PandoraContractRegistry }): PandoraAgentClient;
+export declare function createRemotePandoraAgentClient(options: PandoraRemoteBackendOptions & { catalog?: PandoraContractRegistry }): PandoraAgentClient;
+export declare function createPandoraAgentClient(options?: PandoraAgentClientFactoryOptions): PandoraAgentClient;
+export declare function connectPandoraAgentClient(options?: PandoraAgentClientFactoryOptions): Promise<PandoraAgentClient>;
+export declare const generated: PandoraGeneratedCatalogModule;