Skip to main content

Documentation Index

Fetch the complete documentation index at: https://hastekit.ai/docs/llms.txt

Use this file to discover all available pages before exploring further.

​
Prerequisites

​
Install HasteKit SDK

go get -u github.com/hastekit/hastekit-sdk-go

​
Setting up the SDK

package main

import (
    hastekit "github.com/hastekit/hastekit-sdk-go"
    "github.com/hastekit/hastekit-sdk-go/pkg/gateway"
    "github.com/hastekit/hastekit-sdk-go/pkg/gateway/llm"
    "github.com/hastekit/hastekit-sdk-go/pkg/gateway/llm/responses"
)

func main() {
	client, err := hastekit.New(&hastekit.ClientOptions{
        ProviderConfigs: []gateway.ProviderConfig{
            {
                ProviderName:  llm.ProviderNameOpenAI,
                BaseURL:       "",
                CustomHeaders: nil,
                ApiKeys: []*gateway.APIKeyConfig{
                    {
                        Name:   "Key 1",
                        APIKey: os.Getenv("OPENAI_API_KEY"),
                    },
                },
            },
        },
    })
}

​
Making LLM Calls

Make a call to the model provider to generate a response: 
resp, err := client.NewResponses(ctx, &responses.Request{
    Model:        "OpenAI/gpt-4.1-mini",
    Instructions: utils.Ptr("You are a helpful assistant."),
    Input: responses.InputUnion{
        OfString: utils.Ptr("What is the capital of France?"),
    },
})
Finally, extract the generated text from the response: 
for _, output := range resp.Output {
    if output.OfOutputMessage != nil {
        for _, content := range output.OfOutputMessage.Content {
            if content.OfOutputText != nil {
                fmt.Println(content.OfOutputText.Text)
            }
        }
    }
}

Responses API

Learn more about making LLM calls with the Responses API.

​
Creating Agents

Create a simple agent with system instructions and an LLM: 
agent := client.NewAgent(&hastekit.AgentOptions{
    Name:        "Assistant",
    Instruction: client.Prompt("You are a helpful assistant."),
    LLM: client.NewLLM(hastekit.LLMOptions{
        Provider: llm.ProviderNameOpenAI,
        Model:    "gpt-4o-mini",
    }),
})
Execute the agent with user messages. Execute() returns an *AgentHandle; the simplest way to get the aggregated AgentOutput is handle.Result(), which drains the chunk stream internally. To render chunks live (e.g. forward to a UI), range over handle.Chunks yourself and then call handle.Wait(). 
handle, err := agent.Execute(ctx, &agents.AgentInput{
    Messages: []responses.InputMessageUnion{
        responses.UserMessage("Hello!"),
    },
})
if err != nil {
    log.Fatal(err)
}

out, err := handle.Result()
if err != nil {
    log.Fatal(err)
}
Extract the agent’s response: 
for _, output := range out.Output {
    if output.OfOutputMessage != nil {
        for _, content := range output.OfOutputMessage.Content {
            if content.OfOutputText != nil {
                fmt.Println(content.OfOutputText.Text)
            }
        }
    }
}

Agents

Learn more about building agents with the Agent SDK.