npm install danube

import { DanubeClient } from 'danube';

// Initialize with API key (or set DANUBE_API_KEY environment variable)
const client = new DanubeClient({ apiKey: 'YOUR_API_KEY' });

// List available services
const services = await client.services.list({ limit: 5 });
for (const service of services) {
  console.log(`${service.name}: ${service.toolCount} tools`);
}

// Search for tools
const tools = await client.tools.search('send email');

// Execute a tool
const result = await client.tools.execute({
  toolName: 'Gmail - Send Email',
  parameters: {
    to: 'user@example.com',
    subject: 'Hello from Danube!',
  },
});

if (result.success) {
  console.log(result.result);
} else {
  console.log(`Error: ${result.error}`);
}

// Clean up when done
client.close();

// List/search services
const services = await client.services.list({ query: 'github', limit: 10 });

// Get a specific service
const service = await client.services.get('service-uuid');

// Get tools for a service
const result = await client.services.getTools('service-uuid');
if (result.needsConfiguration) {
  console.log('Service needs credential configuration');
} else {
  for (const tool of result.tools) {
    console.log(tool.name);
  }
}

// Search for tools
const tools = await client.tools.search('send email', { serviceId: 'optional-filter' });

// Get a specific tool
const tool = await client.tools.get('tool-uuid');

// Execute by ID (faster)
const result = await client.tools.execute({
  toolId: 'tool-uuid',
  parameters: { key: 'value' },
});

// Execute by name (searches first)
const result = await client.tools.execute({
  toolName: 'Gmail - Send Email',
  parameters: { to: 'user@example.com' },
});

// Check result
if (result.success) {
  console.log(result.result);
  console.log(`Took ${result.durationMs}ms`);
} else {
  console.log(`Error: ${result.error}`);
}

// Batch execute (up to 10 calls)
const results = await client.tools.batchExecute([
  { toolId: 'tool-uuid-1', toolInput: { city: 'San Francisco' } },
  { toolId: 'tool-uuid-2', toolInput: { city: 'New York' } },
]);
for (const r of results) {
  console.log(`${r.toolId}: ${r.success ? 'ok' : r.error}`);
}

// Search for skills
const skills = await client.skills.search('pdf processing');

// Get full skill content by ID
const skill = await client.skills.get({ skillId: 'skill-uuid' });
// or by name
const skill = await client.skills.get({ skillName: 'pdf-processing' });

console.log(`Instructions:\n${skill.skillMd}`);

for (const script of skill.scripts) {
  console.log(`Script: ${script.name}`);
  console.log(script.content);
}

const context = await client.context.get();
console.log(context.markdown);
console.log(context.organization?.name, context.personalDocuments.length);

const text = await client.context.getMarkdown();

// Remember something in a personal document (created when missing)
await client.context.remember('Prefers weekly summaries on Mondays.');
await client.context.remember('# Role\nSupport lead', { document: 'role.md', mode: 'replace' });

await client.context.setTimezone('Europe/Oslo');

import { readFile, writeFile } from 'node:fs/promises';

await client.skills.upload(await readFile('refund-policy.zip'), { visibility: 'internal', orgId: 'org-uuid' });
const orgSkills = await client.skills.listOrg('org-uuid');
await writeFile('refund-policy.zip', await client.skills.download('skill-uuid'));

// List public workflows
const workflows = await client.workflows.list({ query: 'data pipeline', limit: 10 });

// Get a specific workflow
const workflow = await client.workflows.get('workflow-uuid');

// Execute a workflow with inputs
const execution = await client.workflows.execute('workflow-uuid', {
  query: 'latest news',
});
console.log(`Status: ${execution.status}`);

for (const step of execution.stepResults) {
  console.log(`Step ${step.stepNumber}: ${step.status}`);
}

// Get a past execution result
const past = await client.workflows.getExecution('execution-uuid');
console.log(`Completed in ${past.executionTimeMs}ms`);

// Create a workflow
const created = await client.workflows.create({
  name: 'My Pipeline',
  steps: [
    {
      stepNumber: 1,
      toolId: 'tool-uuid',
      toolName: 'Weather - Get Forecast',
      description: 'Fetch forecast',
      inputMapping: { city: '{{inputs.city}}' },
    },
  ],
  visibility: 'private',
  tags: ['weather'],
});

// Update a workflow
const updated = await client.workflows.update('workflow-uuid', {
  name: 'Renamed Pipeline',
});

// Delete a workflow
await client.workflows.delete('workflow-uuid');

// Store a credential for a service
const stored = await client.credentials.store({
  serviceId: 'service-uuid',
  credentialType: 'api_key',
  credentialValue: 'sk-...',
});
console.log(`Stored for ${stored.serviceName}: ${stored.success}`);

// Get wallet balance
const balance = await client.wallet.getBalance();
console.log(`Balance: $${balance.balanceDollars}`);

// Get transaction history
const transactions = await client.wallet.getTransactions({ limit: 20 });
for (const tx of transactions) {
  console.log(`${tx.type}: ${tx.amountCents} cents`);
}

// Register a new autonomous agent
const agent = await client.agents.register({
  name: 'MyBot',
  operatorEmail: 'operator@example.com',
});
console.log(`Agent ID: ${agent.agentId}`);
console.log(`API Key: ${agent.apiKey}`);

// Get agent info (requires agent's API key)
const info = await client.agents.getInfo();

// Fund the agent's wallet
const funding = await client.agents.fundWallet({
  method: 'card_checkout',
  amountCents: 10000,
});
if (funding.checkoutUrl) {
  console.log(`Complete payment: ${funding.checkoutUrl}`);
}

import { DanubeClient, AuthenticationError, NotFoundError, ExecutionError, RateLimitError, ConfigurationRequiredError } from 'danube';

const client = new DanubeClient();

try {
  const result = await client.tools.execute({ toolId: 'invalid-id' });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.log('Invalid API key');
  } else if (error instanceof NotFoundError) {
    console.log(`Not found: ${error.resource} ${error.identifier}`);
  } else if (error instanceof ExecutionError) {
    console.log(`Execution failed: ${error.message}`);
  } else if (error instanceof ConfigurationRequiredError) {
    console.log(`Configure credentials for service: ${error.serviceId}`);
  } else if (error instanceof RateLimitError) {
    if (error.retryAfter) {
      console.log(`Rate limited. Retry in ${error.retryAfter}s`);
    }
  }
}

const client = new DanubeClient({
  apiKey: 'YOUR_API_KEY',
  baseUrl: 'https://api.danubeai.com',
  timeout: 60,
  maxRetries: 5,
});