zlei6/ragflow
1
0
Fork 0
mirror of https://github.com/infiniflow/ragflow.git synced 2026-06-29 15:31:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Go CLI: fix model related commands (#16368)

Browse Source 
### What problem does this PR solve?

```
RAGFlow(api/default)> show provider 'zhipu-ai'

RAGFlow(api/default)> show provider 'zhipu-ai' instance 'test';

RAGFlow(api/default)> show provider 'zhipu-ai' instance 'test' balance;

RAGFlow(api/default)> show provider 'zhipu-ai' model 'glm-4.5';
```

### Type of change

- [x] Refactoring

---------

Signed-off-by: Jin Hai <haijin.chn@gmail.com>
This commit is contained in:
Jin Hai
2026-06-26 07:07:49 +08:00
committed by GitHub
parent dbefadd86a
commit 58da1d6bc3
2 changed files with 83 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
internal/cli/cli_http.go
View File

@@ -340,8 +340,14 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
return c.CommonShowCurrentCommand(cmd)
case "api_list_available_providers":
return c.CommonAvailableProvidersCommand(cmd)
case "show_provider":
case "api_show_provider":
return c.CommonShowProviderCommand(cmd)
case "api_show_provider_instance":
return c.CommonShowProviderInstanceCommand(cmd)
case "api_show_provider_instance_balance":
return c.CommonShowProviderInstanceBalanceCommand(cmd)
case "api_show_provider_model":
return c.CommonShowProviderModelCommand(cmd)
case "list_provider_models":
return c.CommonListModelsCommand(cmd)
case "api_list_provider_instance_models":
@@ -368,10 +374,6 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
return c.CreateProviderInstance(cmd)
case "api_list_provider_instances":
return c.CommonListProviderInstances(cmd)
case "show_provider_instance":
return c.CommonShowProviderInstanceCommand(cmd)
case "show_instance_balance":
return c.ShowInstanceBalance(cmd)
case "alter_provider_instance":
return c.CommonAlterProviderInstanceCommand(cmd)
case "drop_provider_instance":

156
internal/cli/user_parser.go
View File

@@ -524,13 +524,9 @@ func (p *Parser) parseAPIShowCommands() (*Command, error) {
case TokenVar:
return p.parseShowVariable()
case TokenProvider:
return p.parseShowProvider()
return p.parseAPIShowProviderCommands()
case TokenModel:
return p.parseShowModel()
case TokenInstance:
return p.parseShowInstance()
case TokenBalance:
return p.parseShowBalance()
case TokenTask:
return p.parseShowTask()
case TokenQuotedString:
@@ -630,19 +626,90 @@ func (p *Parser) parseShowModel() (*Command, error) {
return cmd, nil
}
// parseShowProvider parses SHOW PROVIDER <name> command
func (p *Parser) parseShowProvider() (*Command, error) {
// SHOW PROVIDER <name>
// SHOW PROVIDER <name> INSTANCE <instance_name>
// SHOW PROVIDER <name> INSTANCE <instance_name> BALANCE
// SHOW PROVIDER 'provider_name' MODEL 'model_name';
func (p *Parser) parseAPIShowProviderCommands() (*Command, error) {
p.nextToken() // consume PROVIDER
providerName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected provider name: %w", err)
}
p.nextToken() // consume provider_name
cmd := NewCommand("show_provider")
switch p.curToken.Type {
case TokenInstance:
return p.parseAPIShowProviderInstance(providerName)
case TokenModel:
return p.parseAPIShowProviderModel(providerName)
case TokenSemicolon, TokenEOF:
p.nextToken()
default:
return nil, fmt.Errorf("unknown SHOW target: %s", p.curToken.Value)
}
cmd := NewCommand("api_show_provider")
cmd.Params["provider_name"] = providerName
return cmd, nil
}
// SHOW PROVIDER <name> INSTANCE <instance_name>
func (p *Parser) parseAPIShowProviderInstance(providerName string) (*Command, error) {
p.nextToken() // consume INSTANCE
instanceName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected instance name: %w", err)
}
p.nextToken() // consume instance_name
if p.curToken.Type == TokenBalance {
return p.parseAPIShowProviderInstanceBalance(providerName, instanceName)
}
cmd := NewCommand("api_show_provider_instance")
cmd.Params["instance_name"] = instanceName
cmd.Params["provider_name"] = providerName
// Semicolon is optional
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
// SHOW PROVIDER <name> INSTANCE <instance_name> BALANCE
func (p *Parser) parseAPIShowProviderInstanceBalance(providerName, instanceName string) (*Command, error) {
p.nextToken() // consume BALANCE
cmd := NewCommand("api_show_provider_instance_balance")
cmd.Params["instance_name"] = instanceName
cmd.Params["provider_name"] = providerName
// Semicolon is optional
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
// SHOW PROVIDER <name> MODEL <model_name>
func (p *Parser) parseAPIShowProviderModel(providerName string) (*Command, error) {
p.nextToken() // consume MODEL
modelName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected model name: %w", err)
}
p.nextToken() // consume model_name
cmd := NewCommand("api_show_provider_model")
cmd.Params["model_name"] = modelName
cmd.Params["provider_name"] = providerName
p.nextToken()
// Semicolon is optional
if p.curToken.Type == TokenSemicolon {
p.nextToken()
@@ -1650,77 +1717,6 @@ optionsLoop:
return cmd, nil
}
// parseShowInstance parses SHOW INSTANCE <name> FROM PROVIDER <name> command
func (p *Parser) parseShowInstance() (*Command, error) {
p.nextToken() // consume INSTANCE
instanceName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected instance name: %w", err)
}
p.nextToken()
if p.curToken.Type != TokenFrom {
return nil, fmt.Errorf("expected FROM")
}
p.nextToken()
providerName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected provider name after FROM PROVIDER: %w", err)
}
cmd := NewCommand("show_provider_instance")
cmd.Params["instance_name"] = instanceName
cmd.Params["provider_name"] = providerName
p.nextToken()
// Semicolon is optional
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
// parseShowBalance parses SHOW BALANCE FROM <provider_name> <instance_name>
func (p *Parser) parseShowBalance() (*Command, error) {
p.nextToken() // consume INSTANCE
if p.curToken.Type != TokenFrom {
return nil, fmt.Errorf("expected FROM")
}
p.nextToken()
if p.curToken.Type != TokenQuotedString {
return nil, fmt.Errorf("expected provider name after FROM PROVIDER")
}
providerName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected provider name after FROM PROVIDER: %w", err)
}
p.nextToken()
if p.curToken.Type != TokenQuotedString {
return nil, fmt.Errorf("expected instance name")
}
instanceName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected instance name: %w", err)
}
p.nextToken()
cmd := NewCommand("show_instance_balance")
cmd.Params["instance_name"] = instanceName
cmd.Params["provider_name"] = providerName
p.nextToken()
// Semicolon is optional
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
// parseShowTask parses SHOW TASK <task>
func (p *Parser) parseShowTask() (*Command, error) {
p.nextToken() // consume TASK