Upgrading Guide

npm list dedalus-labs

// package.json
{
  "dependencies": {
    "dedalus-labs": "^0.1.0-alpha.8",
    "dedalus-labs-mcp": "^0.1.0-alpha.8" // If using MCP server
  }
}

git checkout -b upgrade-dedalus-sdk

# Update to latest version
npm install dedalus-labs@latest

# If using MCP server
npm install dedalus-labs-mcp@latest

npm install [email protected]

rm -rf node_modules package-lock.json
npm install

npx tsc --noEmit

npm test

import Dedalus from 'dedalus-labs';

const client = new Dedalus({
  apiKey: process.env.DEDALUS_API_KEY
});

// Test basic completion
const completion = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [{ role: 'user', content: 'Hello' }]
});

console.log('SDK working:', completion.id);

import Dedalus from 'dedalus-labs';

const client = new Dedalus({ apiKey: 'key' });

let messages = [{ role: 'user', content: 'What is 2+2?' }];

while (true) {
  const response = await client.chat.completions.create({
    model: 'openai/gpt-4',
    messages,
    tools: [/* your tools */]
  });
  
  const message = response.choices[0].message;
  messages.push(message);
  
  if (!message.tool_calls) break;
  
  // Manual tool execution...
  for (const toolCall of message.tool_calls) {
    // Execute tool and add result to messages
  }
}

import { Dedalus, DedalusRunner } from 'dedalus-labs';

const client = new Dedalus({ apiKey: 'key' });
const runner = new DedalusRunner(client);

const result = await runner.run({
  model: 'openai/gpt-4',
  input: 'What is 2+2?',
  tools: [/* your tools */],
  maxSteps: 10
});

console.log(result.output);

// Custom server implementation
const server = createServer();
server.addTool('create_completion', async (params) => {
  const client = new Dedalus({ apiKey: 'key' });
  return await client.chat.completions.create(params);
});

# Use the official MCP server
npx -y dedalus-labs-mcp --tools=all

import { server, initMcpServer } from 'dedalus-labs-mcp/server';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

initMcpServer({ server });

const transport = new StdioServerTransport();
await server.connect(transport);

const completion = await client.chat.completions.create({
  model: 'gpt-4',
  // ...
});

// More explicit provider/model format
const completion = await client.chat.completions.create({
  model: 'openai/gpt-4',
  // ...
});

// Or use model objects
const completion = await client.chat.completions.create({
  model: { model: 'gpt-4', provider: 'openai' },
  // ...
});

// Multi-model support
const completion = await client.chat.completions.create({
  model: [
    'anthropic/claude-3-5-sonnet-20241022',
    'openai/gpt-4'
  ],
  // ...
});

const completion = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [{ role: 'user', content: 'Return JSON' }]
});

const data = JSON.parse(completion.choices[0].message.content);

import { z } from 'zod';
import { toSchema } from 'dedalus-labs/lib/runner';

const schema = z.object({
  name: z.string(),
  age: z.number()
});

const completion = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [{ role: 'user', content: 'Return structured data' }],
  response_format: toSchema(schema)
});

// Guaranteed to match schema
const data = JSON.parse(completion.choices[0].message.content);

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [{ role: 'user', content: 'Hello' }],
  stream: true
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

import type { Stream } from 'dedalus-labs/core/streaming';
import type { StreamChunk } from 'dedalus-labs/resources/chat/completions';

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [{ role: 'user', content: 'Hello' }],
  stream: true
}) as Stream<StreamChunk>;

for await (const chunk of stream) {
  const content = chunk.choices?.[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

// Before
import type { Model } from 'dedalus-labs';

// After
import type { DedalusModel } from 'dedalus-labs';

// Now valid
const completion = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: null
});

// Before
initMcpServer({ server, includeAllTools: true });

// After
initMcpServer({
  server,
  mcpOptions: { includeAllTools: true }
});

// Deprecated
const result = await runner.run({
  model: 'openai/gpt-4',
  input: 'Hello',
  returnIntent: true // Deprecated
});

// Use instead
const result = await runner.run({
  model: 'openai/gpt-4',
  input: 'Hello',
  autoExecuteTools: false // Inspect tool_calls without executing
});

{
  "dependencies": {
    "dedalus-labs": "0.1.0-alpha.8" // Exact version, no caret
  }
}

# Update both SDK and MCP server together
npm install dedalus-labs@latest dedalus-labs-mcp@latest

npx tsc --noEmit --listFiles | grep dedalus

const client = new Dedalus({
  apiKey: 'key',
  logLevel: 'debug'
});

const USE_RUNNER = process.env.FEATURE_USE_RUNNER === 'true';

if (USE_RUNNER) {
  const runner = new DedalusRunner(client);
  result = await runner.run(params);
} else {
  // Old implementation
}

npm install [email protected] # Previous working version

git checkout main
git branch -D upgrade-dedalus-sdk

rm -rf node_modules package-lock.json
npm install

try {
  const result = await client.chat.completions.create(params);
} catch (error) {
  console.error('Dedalus SDK error:', error);
  // Send to your monitoring system
  monitoring.captureException(error);
}

const start = Date.now();
const result = await client.chat.completions.create(params);
const duration = Date.now() - start;

metrics.record('dedalus.completion.duration', duration);

const result = await runner.run(params);

console.log('Steps used:', result.stepsUsed);
console.log('Tools called:', result.toolsCalled);

// Alert if unusual
if (result.stepsUsed > 8) {
  alerts.send('High step count in runner');
}