TypeScript SDK

npm install @openserv-labs/sdk

import { Agent } from '@openserv-labs/sdk'
import { z } from 'zod'

// Initialize the agent
const agent = new Agent({
  systemPrompt: 'You are a helpful assistant.',
  apiKey: process.env.OPENSERV_API_KEY
})

// Add a capability
agent.addCapability({
  name: 'greet',
  description: 'Greet a user by name',
  schema: z.object({
    name: z.string().describe('The name of the user to greet')
  }),
  async run({ args }) {
    return `Hello, ${args.name}! How can I help you today?`
  }
})

// Or add multiple capabilities at once
agent.addCapabilities([
  {
    name: 'farewell',
    description: 'Say goodbye to a user',
    schema: z.object({
      name: z.string().describe('The name of the user to bid farewell')
    }),
    async run({ args }) {
      return `Goodbye, ${args.name}! Have a great day!`
    }
  },
  {
    name: 'help',
    description: 'Show available commands',
    schema: z.object({}),
    async run() {
      return 'Available commands: greet, farewell, help'
    }
  }
])

// Start the agent server
agent.start()

import { Agent } from '@openserv-labs/sdk'
import { z } from 'zod'

const agent = new Agent({
  systemPrompt: 'You are a helpful assistant.'
})

// Add a single capability
agent.addCapability({
  name: 'summarize',
  description: 'Summarize a piece of text',
  schema: z.object({
    text: z.string().describe('Text content to summarize'),
    maxLength: z.number().optional().describe('Maximum length of summary')
  }),
  async run({ args, action }) {
    const { text, maxLength = 100 } = args

    // Your summarization logic here
    const summary = `Summary of text (${text.length} chars): ...`

    // Log progress to the task
    await action.task.addLog({
      severity: 'info',
      type: 'text',
      body: 'Generated summary successfully'
    })

    return summary
  }
})

// Add multiple capabilities at once
agent.addCapabilities([
  {
    name: 'analyze',
    description: 'Analyze text for sentiment and keywords',
    schema: z.object({
      text: z.string().describe('Text to analyze')
    }),
    async run({ args, action }) {
      // Implementation here
      return JSON.stringify({ result: 'analysis complete' })
    }
  },
  {
    name: 'help',
    description: 'Show available commands',
    schema: z.object({}),
    async run({ args, action }) {
      return 'Available commands: summarize, analyze, help'
    }
  }
])

const customerSupportAgent = new Agent({
  systemPrompt: 'You are a customer support agent.',
  capabilities: [
    {
      name: 'respondToCustomer',
      description: 'Generate a response to a customer inquiry',
      schema: z.object({
        query: z.string(),
        context: z.string().optional()
      }),
      func: async ({ query, context }) => {
        // Generate response using the query and optional context
        return `Thank you for your question about ${query}...`
      }
    }
  ]
})

// Send a chat message
await agent.sendChatMessage({
  workspaceId: 123,
  agentId: 456,
  message: 'How can I assist you today?'
})

// Upload a file
await agent.uploadFile({
  workspaceId: 123,
  path: 'reports/analysis.txt',
  file: 'Analysis results...',
  skipSummarizer: false,
  taskIds: [456] // Associate with tasks
})

// Get workspace files
const files = await agent.getFiles({
  workspaceId: 123
})

await agent.sendChatMessage({
  workspaceId: number,
  agentId: number,
  message: string
})

const files = await agent.getFiles({
  workspaceId: number
})

await agent.uploadFile({
  workspaceId: number,
  path: string,
  file: Buffer | string,
  skipSummarizer?: boolean,
  taskIds?: number[]
})

const response = await agent.callIntegration({
  workspaceId: number,
  integrationId: string,
  details: {
    endpoint: string,
    method: string,
    data?: object
  }
})

// Example: Sending a tweet using Twitter integration
const response = await agent.callIntegration({
  workspaceId: 123,
  integrationId: 'twitter-v2',
  details: {
    endpoint: '/2/tweets',
    method: 'POST',
    data: {
      text: 'Hello from my AI agent!'
    }
  }
})

const result = await agent.process({
  messages: [
    {
      role: 'system',
      content: 'You are a helpful assistant'
    },
    {
      role: 'user',
      content: 'Create a task to analyze the latest data'
    }
  ]
})

try {
  await agent.doTask(action);
} catch (error) {
  console.error('Agent error:', error);
  // Optionally emit telemetry, retry, or perform fallback behavior here.
}

class DataAnalysisAgent extends Agent {
  protected async doTask(action: z.infer<typeof doTaskActionSchema>) {
    // Implement custom analysis logic
    const result = await this.analyzeData(action.input ?? '');
    return JSON.stringify(result);
  }

  private async analyzeData(input: string) {
    // Custom data analysis implementation
    return { ok: true, length: input.length };
  }
}

MIT License

Copyright (c) 2024 OpenServ Labs

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.