package chatd

import (

"context"

"encoding/json"

"charm.land/fantasy"

"cdr.dev/slog/v3"

"github.com/coder/coder/v2/codersdk"

)

// dynamicTool wraps a codersdk.DynamicTool as a fantasy.AgentTool.

// These tools are presented to the LLM but never executed by the

// chatloop — when the LLM calls one, the chatloop exits with

// requires_action status and the client handles execution.

// The Run method should never be called; it returns an error if

// it is, as a safety net.

type dynamicTool struct {

name string

description string

parameters map[string]any

required []string

opts fantasy.ProviderOptions

}

// dynamicToolsFromSDK converts codersdk.DynamicTool definitions

// into fantasy.AgentTool implementations for inclusion in the LLM

// tool list.

func dynamicToolsFromSDK(logger slog.Logger, tools []codersdk.DynamicTool) []fantasy.AgentTool {

if len(tools) == 0 {

return nil

}

result := make([]fantasy.AgentTool, 0, len(tools))

for _, t := range tools {

dt := &dynamicTool{

name: t.Name,

description: t.Description,

}

// InputSchema is a full JSON Schema object stored as

// json.RawMessage. Extract the "properties" and

// "required" fields that fantasy.ToolInfo expects.

if len(t.InputSchema) > 0 {

var schema struct {

Properties map[string]any `json:"properties"`

Required []string `json:"required"`

}

if err := json.Unmarshal(t.InputSchema, &schema); err != nil {

// Defensive: present the tool with no parameter

// constraints rather than failing. The LLM may

// hallucinate argument shapes, but the tool will

// still appear in the tool list.

logger.Warn(context.Background(), "failed to parse dynamic tool input schema",

slog.F("tool_name", t.Name),

slog.Error(err))

} else {

dt.parameters = schema.Properties

dt.required = schema.Required

}

}

result = append(result, dt)

}

return result

}

func (t *dynamicTool) Info() fantasy.ToolInfo {

return fantasy.ToolInfo{

Name: t.name,

Description: t.description,

Parameters: t.parameters,

Required: t.required,

}

}

func (*dynamicTool) Run(_ context.Context, _ fantasy.ToolCall) (fantasy.ToolResponse, error) {

// Dynamic tools are never executed by the chatloop. If this

// method is called, it indicates a bug in the chatloop's

// dynamic tool detection logic.

return fantasy.NewTextErrorResponse(

"dynamic tool called in chatloop — this is a bug; " +

"dynamic tools should be handled by the client",

), nil

}

func (t *dynamicTool) ProviderOptions() fantasy.ProviderOptions {

return t.opts

}

func (t *dynamicTool) SetProviderOptions(opts fantasy.ProviderOptions) {

t.opts = opts

}