Skip to content

Open source AI coding agent. Designed for large projects and real world tasks.

wip: connecting claude subscription basically works; now doing rate limit handling/cooldown, integrated models mode, and docs/onboarding updates

Dane Schneidercb4591fe601e
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.go
index 1550cb90..6d4de9b6 100644
--- a/app/cli/api/methods.go
+++ b/app/cli/api/methods.go
@@ -1406,6 +1406,68 @@ func (a *Api) ListOrgs() ([]*shared.Org, *shared.ApiError) {
return orgs, nil
}
+func (a *Api) GetOrgUserConfig() (*shared.OrgUserConfig, *shared.ApiError) {
+ serverUrl := GetApiHost() + "/org_user_config"
+ resp, err := authenticatedFastClient.Get(serverUrl)
+ if err != nil {
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode >= 400 {
+ errorBody, _ := io.ReadAll(resp.Body)
+ apiErr := HandleApiError(resp, errorBody)
+ authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+ if authRefreshed {
+ return a.GetOrgUserConfig()
+ }
+ return nil, apiErr
+ }
+
+ var orgUserConfig shared.OrgUserConfig
+ err = json.NewDecoder(resp.Body).Decode(&orgUserConfig)
+ if err != nil {
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+ }
+
+ return &orgUserConfig, nil
+}
+
+func (a *Api) UpdateOrgUserConfig(c shared.OrgUserConfig) *shared.ApiError {
+ serverUrl := GetApiHost() + "/org_user_config"
+
+ reqBytes, err := json.Marshal(c)
+
+ if err != nil {
+ return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+ }
+
+ request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+ if err != nil {
+ return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+ }
+
+ request.Header.Set("Content-Type", "application/json")
+
+ resp, err := authenticatedFastClient.Do(request)
+ if err != nil {
+ return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode >= 400 {
+ errorBody, _ := io.ReadAll(resp.Body)
+ apiErr := HandleApiError(resp, errorBody)
+ authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+ if authRefreshed {
+ return a.UpdateOrgUserConfig(c)
+ }
+ return apiErr
+ }
+
+ return nil
+}
+
func (a *Api) DeleteUser(userId string) *shared.ApiError {
serverUrl := fmt.Sprintf("%s/orgs/users/%s", GetApiHost(), userId)
req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
diff --git a/app/cli/cmd/apply.go b/app/cli/cmd/apply.go
index df461185..4266ec1f 100644
--- a/app/cli/cmd/apply.go
+++ b/app/cli/cmd/apply.go
@@ -1,13 +1,11 @@
package cmd
import (
- "plandex-cli/api"
"plandex-cli/auth"
"plandex-cli/lib"
"plandex-cli/plan_exec"
"plandex-cli/term"
"plandex-cli/types"
- shared "plandex-shared"
"github.com/spf13/cobra"
)
@@ -33,21 +31,16 @@ func apply(cmd *cobra.Command, args []string) {
auth.MustResolveAuthWithOrg()
lib.MustResolveProject()
- var config *shared.PlanConfig
if fullAuto {
term.StartSpinner("")
- var apiErr *shared.ApiError
- config, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
- if apiErr != nil {
- term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
- }
+ config := lib.MustGetCurrentPlanConfig()
_, updatedConfig, printFn := resolveAutoModeSilent(config)
- config = updatedConfig
+ lib.SetCachedPlanConfig(updatedConfig)
term.StopSpinner()
printFn()
}
- mustSetPlanExecFlagsWithConfig(cmd, config, true)
+ mustSetPlanExecFlags(cmd, true)
if lib.CurrentPlanId == "" {
term.OutputNoCurrentPlanErrorAndExit()
diff --git a/app/cli/cmd/build.go b/app/cli/cmd/build.go
index 552eb961..18c899ce 100644
--- a/app/cli/cmd/build.go
+++ b/app/cli/cmd/build.go
@@ -38,6 +38,7 @@ func init() {
func build(cmd *cobra.Command, args []string) {
auth.MustResolveAuthWithOrg()
lib.MustResolveProject()
+
mustSetPlanExecFlags(cmd, false)
var apiKeys map[string]string
diff --git a/app/cli/cmd/claude_max.go b/app/cli/cmd/claude_max.go
new file mode 100644
index 00000000..fd330fd2
--- /dev/null
+++ b/app/cli/cmd/claude_max.go
@@ -0,0 +1,32 @@
+package cmd
+
+import (
+ "plandex-cli/lib"
+
+ "github.com/spf13/cobra"
+)
+
+var connectClaudeCmd = &cobra.Command{
+ Use: "connect-claude",
+ Short: "Connect your Claude Pro or Max subscription",
+ Run: connectClaude,
+}
+
+var disconnectClaudeCmd = &cobra.Command{
+ Use: "disconnect-claude",
+ Short: "Disconnect your Claude Pro or Max subscription",
+ Run: disconnectClaude,
+}
+
+func connectClaude(cmd *cobra.Command, args []string) {
+ lib.ConnectClaudeMax()
+}
+
+func disconnectClaude(cmd *cobra.Command, args []string) {
+ lib.DisconnectClaudeMax()
+}
+
+func init() {
+ RootCmd.AddCommand(connectClaudeCmd)
+ RootCmd.AddCommand(disconnectClaudeCmd)
+}
diff --git a/app/cli/cmd/model_providers.go b/app/cli/cmd/model_providers.go
index 04b646a9..4798544a 100644
--- a/app/cli/cmd/model_providers.go
+++ b/app/cli/cmd/model_providers.go
@@ -98,6 +98,8 @@ func listProviders(cmd *cobra.Command, args []string) {
apiKey = config.ApiKeyEnvVar
} else if config.SkipAuth {
apiKey = "No Auth"
+ } else if config.HasClaudeMaxAuth {
+ apiKey = "Claude Max Oauth"
}
extraVars := []string{}
diff --git a/app/cli/cmd/plan_exec_helpers.go b/app/cli/cmd/plan_exec_helpers.go
index 95c69f4c..464806d1 100644
--- a/app/cli/cmd/plan_exec_helpers.go
+++ b/app/cli/cmd/plan_exec_helpers.go
@@ -3,7 +3,6 @@ package cmd
import (
"fmt"
"os"
- "plandex-cli/api"
"plandex-cli/lib"
"plandex-cli/term"
"strconv"
@@ -157,21 +156,11 @@ func validatePlanExecFlags(isApply bool) {
}
func mustSetPlanExecFlags(cmd *cobra.Command, isApply bool) {
- mustSetPlanExecFlagsWithConfig(cmd, nil, isApply)
-}
-
-func mustSetPlanExecFlagsWithConfig(cmd *cobra.Command, config *shared.PlanConfig, isApply bool) {
if lib.CurrentPlanId == "" {
term.OutputNoCurrentPlanErrorAndExit()
}
- if config == nil {
- var apiErr *shared.ApiError
- config, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
- if apiErr != nil {
- term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
- }
- }
+ config := lib.MustGetCurrentPlanConfig()
// Set flag vars from config when flags aren't explicitly set
if !cmd.Flags().Changed("stop") {
diff --git a/app/cli/cmd/plan_start_helpers.go b/app/cli/cmd/plan_start_helpers.go
index 01339d39..8df44944 100644
--- a/app/cli/cmd/plan_start_helpers.go
+++ b/app/cli/cmd/plan_start_helpers.go
@@ -87,6 +87,7 @@ func resolveAutoModeWithArgs(config *shared.PlanConfig, silent bool) (bool, *sha
apiErr := api.Client.UpdatePlanConfig(lib.CurrentPlanId, shared.UpdatePlanConfigRequest{
Config: updatedConfig,
})
+ lib.SetCachedPlanConfig(updatedConfig)
if !silent {
term.StopSpinner()
}
diff --git a/app/cli/cmd/repl.go b/app/cli/cmd/repl.go
index ff8c21a4..aeee55df 100644
--- a/app/cli/cmd/repl.go
+++ b/app/cli/cmd/repl.go
@@ -62,11 +62,7 @@ func init() {
}
func setReplConfig() {
- res, apiErr := api.Client.GetPlanConfig(lib.CurrentPlanId)
- if apiErr != nil {
- term.OutputErrorAndExit("Error getting plan config: %v", apiErr.Msg)
- }
- replConfig = res
+ replConfig = lib.MustGetCurrentPlanConfig()
}
func runRepl(cmd *cobra.Command, args []string) {
@@ -147,6 +143,8 @@ func runRepl(cmd *cobra.Command, args []string) {
afterNew = true
}
+ setReplConfig()
+
if !auth.Current.IntegratedModelsMode {
lib.MustVerifyAuthVars()
}
@@ -156,8 +154,6 @@ func runRepl(cmd *cobra.Command, args []string) {
color.New(term.ColorHiRed).Printf("Error getting project paths: %v\n", err)
}
- setReplConfig()
-
settings, apiErr := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
if apiErr != nil {
term.OutputErrorAndExit("Error getting settings: %v", apiErr.Msg)
diff --git a/app/cli/cmd/root.go b/app/cli/cmd/root.go
index f11c2ae3..0a45fe9d 100644
--- a/app/cli/cmd/root.go
+++ b/app/cli/cmd/root.go
@@ -85,6 +85,8 @@ func init() {
}
RootCmd.AddCommand(helpCmd)
+ RootCmd.AddCommand(connectClaudeCmd)
+ RootCmd.AddCommand(disconnectClaudeCmd)
// add an --all/-a flag
helpCmd.Flags().BoolVarP(&helpShowAll, "all", "a", false, "Show all commands")
diff --git a/app/cli/cmd/set_model.go b/app/cli/cmd/set_model.go
index 2e9bb16e..132969bc 100644
--- a/app/cli/cmd/set_model.go
+++ b/app/cli/cmd/set_model.go
@@ -175,15 +175,18 @@ func updateModelSettings(args []string, originalSettings *shared.PlanSettings, d
errCh <- fmt.Errorf("error getting default config: %v", apiErr.Msg)
return
}
+
errCh <- nil
}()
go func() {
- var apiErr *shared.ApiError
- planConfig, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
- if apiErr != nil {
- errCh <- fmt.Errorf("error getting plan config: %v", apiErr.Msg)
- return
+ if lib.CurrentPlanId != "" {
+ var apiErr *shared.ApiError
+ planConfig, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
+ if apiErr != nil {
+ errCh <- fmt.Errorf("error getting plan config: %v", apiErr.Msg)
+ return
+ }
}
errCh <- nil
}()
diff --git a/app/cli/go.mod b/app/cli/go.mod
index b424d265..48b24d2d 100644
--- a/app/cli/go.mod
+++ b/app/cli/go.mod
@@ -88,7 +88,7 @@ require (
github.com/charmbracelet/bubbletea v1.3.0
github.com/charmbracelet/glamour v0.6.0
github.com/charmbracelet/glow v1.5.1
- github.com/cqroot/prompt v0.9.3
+ github.com/cqroot/prompt v0.9.4
github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf
github.com/inconshreveable/mousetrap v1.1.0 // indirect
diff --git a/app/cli/go.sum b/app/cli/go.sum
index a6d20c25..6ad246f5 100644
--- a/app/cli/go.sum
+++ b/app/cli/go.sum
@@ -316,8 +316,8 @@ github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46t
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cqroot/multichoose v0.1.1 h1:diGuKYKea9ePOTwUyUDor9zKRqKFWXGkYGqUa9+firU=
github.com/cqroot/multichoose v0.1.1/go.mod h1:BJzIGqbQZNADPDuA3IzhmTMpRc2F3fZKysMRYP+Ydw8=
-github.com/cqroot/prompt v0.9.3 h1:00Sjiasl1QL7ttEphJ+1xAl0fKQi+7s2F3aY0x7wnz4=
-github.com/cqroot/prompt v0.9.3/go.mod h1:NZvCTeuvR9ew9Hkk7xlrZ9xdVH4AmkO9R0eeBkzOHXQ=
+github.com/cqroot/prompt v0.9.4 h1:uFRlhXuOP3CSD+Pii0Z8VJhgXpavSloFf7/KAERwjz8=
+github.com/cqroot/prompt v0.9.4/go.mod h1:6BVZiEv7XkW1K64y1k2wdzToDwspL3n/RkUIyPjQ808=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
@@ -749,8 +749,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
diff --git a/app/cli/lib/apply.go b/app/cli/lib/apply.go
index 9c441af1..8c262e80 100644
--- a/app/cli/lib/apply.go
+++ b/app/cli/lib/apply.go
@@ -574,8 +574,6 @@ func execApplyScript(
}
func apiApplyPlan(planId, branch string) (string, error) {
- log.Println("Getting API keys")
-
var apiKeys map[string]string
if !auth.Current.IntegratedModelsMode {
apiKeys = MustVerifyAuthVarsSilent()
diff --git a/app/cli/lib/claude_max.go b/app/cli/lib/claude_max.go
new file mode 100644
index 00000000..7b1bc2f7
--- /dev/null
+++ b/app/cli/lib/claude_max.go
@@ -0,0 +1,337 @@
+package lib
+
+import (
+ "bytes"
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "plandex-cli/term"
+ "plandex-cli/types"
+ "plandex-cli/ui"
+ shared "plandex-shared"
+ "strings"
+ "time"
+
+ "github.com/fatih/color"
+)
+
+const claudeMaxClientId = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+const claudeMaxScopes = "org:create_api_key user:profile user:inference"
+const claudeMaxRedirect = "https://console.anthropic.com/oauth/code/callback"
+const claudeMaxTokenUrl = "https://console.anthropic.com/v1/oauth/token"
+
+func hasAnthropicModels(opts shared.ModelProviderOptions) bool {
+ for _, opt := range opts {
+ if opt.Config.Provider == shared.ModelProviderAnthropic {
+ return true
+ }
+ }
+ return false
+}
+
+func promptClaudeMaxIfNeeded() bool {
+ orgUserConfig := MustGetOrgUserConfig()
+ if orgUserConfig.PromptedClaudeMax {
+ return false
+ }
+
+ term.StopSpinner()
+ fmt.Println("ℹ️ The current model pack uses Anthropic models.\nIf you have a " + color.New(color.FgHiGreen, color.Bold).Sprint("Claude Pro or Max Subscription") + ", you can connect to it.\nPlandex will then use your Claude subscription for Anthropic model calls up to your limit.\n")
+
+ res, err := term.ConfirmYesNo("Connect your Claude subscription?")
+ if err != nil {
+ term.OutputErrorAndExit("Error confirming claude connection: %v", err)
+ }
+
+ // update org user config to avoid prompting again
+ orgUserConfig.PromptedClaudeMax = true
+ MustUpdateOrgUserConfig(*orgUserConfig)
+
+ if !res {
+ fmt.Println()
+ color.New(color.FgHiBlue).Println("To connect a Claude subscription later, run:\n" + term.ShowCmd("connect-claude"))
+ fmt.Println()
+ return false
+ }
+
+ ConnectClaudeMax()
+
+ return true
+}
+
+func connectClaudeMaxIfNeeded() bool {
+ accountCreds, err := GetAccountCredentials()
+ if err != nil {
+ term.OutputErrorAndExit("Error getting account credentials: %v", err)
+ }
+
+ if accountCreds == nil || accountCreds.ClaudeMax == nil {
+
+ term.StopSpinner()
+ fmt.Println("ℹ️ You connected a " + color.New(color.FgHiGreen, color.Bold).Sprint("Claude Pro or Max subscription,") + "\nbut credentials weren't found on this device.\n")
+
+ res, err := term.ConfirmYesNo("Connect your Claude subscription?")
+ if err != nil {
+ term.OutputErrorAndExit("Error confirming claude connection: %v", err)
+ }
+
+ if res {
+ ConnectClaudeMax()
+ return true
+ }
+ }
+
+ return false
+}
+
+func refreshClaudeMaxCredsIfNeeded() {
+ accountCreds, err := GetAccountCredentials()
+ if err != nil {
+ term.OutputErrorAndExit("Error getting account credentials: %v", err)
+ }
+ if accountCreds == nil || accountCreds.ClaudeMax == nil {
+ return
+ }
+ if !needsRefresh(accountCreds.ClaudeMax) || accountCreds.ClaudeMax.RefreshToken == "" {
+ return
+ }
+
+ _, status, err := refreshCreds(accountCreds)
+ if err != nil {
+ if status == http.StatusUnauthorized {
+ term.StopSpinner()
+ color.New(color.FgHiYellow, color.Bold).Println("⚠️ Your Claude subscription's connection has been lost")
+ fmt.Println()
+ res, err := term.ConfirmYesNo("Reconnect your Claude subscription?")
+ if err != nil {
+ term.OutputErrorAndExit("Error confirming claude connection: %v", err)
+ }
+ if !res {
+ accountCreds.ClaudeMax = nil
+ if err := SetAccountCredentials(accountCreds); err != nil {
+ term.OutputErrorAndExit("Error clearing Claude credentials: %v", err)
+ }
+ return
+ }
+ ConnectClaudeMax()
+ return
+ }
+ term.OutputErrorAndExit("Error refreshing Claude credentials: %v", err)
+ }
+}
+
+func ConnectClaudeMax() {
+ connectClaudeMaxOauth()
+
+ term.StartSpinner("")
+ orgUserConfig := MustGetOrgUserConfig()
+ orgUserConfig.UseClaudeSubscription = true
+ MustUpdateOrgUserConfig(*orgUserConfig)
+
+ term.StopSpinner()
+ fmt.Println()
+ fmt.Println("✅ Your Claude subscription is now connected")
+ fmt.Println()
+
+ color.New(color.FgHiBlue).Println("To disconnect, run:\n" + term.ShowCmd("disconnect-claude"))
+ fmt.Println()
+}
+
+func DisconnectClaudeMax() {
+ term.StartSpinner("")
+
+ orgUserConfig := MustGetOrgUserConfig()
+ orgUserConfig.UseClaudeSubscription = false
+ MustUpdateOrgUserConfig(*orgUserConfig)
+
+ accountCreds, err := GetAccountCredentials()
+ if err != nil {
+ term.OutputErrorAndExit("Error getting account credentials: %v", err)
+ }
+
+ if accountCreds != nil {
+ accountCreds.ClaudeMax = nil
+ if err := SetAccountCredentials(accountCreds); err != nil {
+ term.OutputErrorAndExit("Error clearing Claude credentials: %v", err)
+ }
+ }
+
+ term.StopSpinner()
+
+ fmt.Println("✅ Your Claude subscription has been disconnected")
+ fmt.Println()
+ color.New(color.FgHiBlue).Println("To reconnect, run:\n" + term.ShowCmd("connect-claude"))
+ fmt.Println()
+}
+
+func connectClaudeMaxOauth() {
+ verifier, err := genCodeVerifier()
+ if err != nil {
+ term.OutputErrorAndExit("Error generating code verifier: %v", err)
+ }
+ challenge := sha256Base64(verifier)
+
+ state, err := genCodeVerifier()
+ if err != nil {
+ term.OutputErrorAndExit("Error generating state: %v", err)
+ }
+
+ authURL := fmt.Sprintf(
+ "https://claude.ai/oauth/authorize?code=true&client_id=%s&response_type=code&scope=%s&redirect_uri=%s&code_challenge=%s&code_challenge_method=S256&state=%s",
+ claudeMaxClientId, url.QueryEscape(claudeMaxScopes), url.QueryEscape(claudeMaxRedirect), challenge, state,
+ )
+
+ term.StopSpinner()
+
+ fmt.Println()
+ ui.OpenURL("Opening Claude authentication page in your default browser...", authURL)
+ fmt.Println()
+
+ color.New(color.FgHiGreen, color.Bold).Println("📋 Click 'Authorize', copy the Authentication Code, then paste it below.\n")
+
+ pastedCode, err := term.GetUserPasswordInput("Authentication Code:")
+ if err != nil {
+ term.OutputErrorAndExit("Error reading pasted authentication code: %v", err)
+ }
+
+ split := strings.SplitN(pastedCode, "#", 2)
+ if len(split) != 2 {
+ term.OutputErrorAndExit("Invalid authentication code: %s", pastedCode)
+ }
+ code := split[0]
+ pastedState := split[1]
+
+ if code == "" || pastedState != state {
+ term.OutputErrorAndExit("Claude authentication failed: missing or mismatched oauth code/state")
+ }
+ term.StartSpinner("")
+
+ tokens, err := exchangeCode(code, verifier, state)
+ if err != nil {
+ term.OutputErrorAndExit("Error exchanging code: %v", err)
+ }
+
+ creds := types.AccountCredentials{
+ ClaudeMax: &types.OauthCreds{
+ OauthResponse: *tokens,
+ ExpiresAt: time.Now().Add(time.Duration(tokens.ExpiresIn) * time.Second),
+ },
+ }
+ if err := SetAccountCredentials(&creds); err != nil {
+ term.OutputErrorAndExit("Error setting account credentials: %v", err)
+ }
+}
+
+func exchangeCode(code, verifier, state string) (*types.OauthResponse, error) {
+ body, _ := json.Marshal(map[string]any{
+ "grant_type": "authorization_code",
+ "code": code,
+ "state": state,
+ "code_verifier": verifier,
+ "redirect_uri": claudeMaxRedirect,
+ "client_id": claudeMaxClientId,
+ })
+ req, err := http.NewRequest("POST", claudeMaxTokenUrl, bytes.NewReader(body))
+ if err != nil {
+ return nil, fmt.Errorf("token exchange failed - error creating request: %s", err)
+ }
+
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("anthropic-beta", shared.AnthropicClaudeMaxBetaHeader)
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ b, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("token exchange failed - error reading body: %s", err)
+ }
+ return nil, fmt.Errorf("token exchange failed - status: %d, body: %s", resp.StatusCode, b)
+ }
+ var t types.OauthResponse
+ if err := json.NewDecoder(resp.Body).Decode(&t); err != nil {
+ return nil, err
+ }
+ return &t, nil
+}
+
+func genCodeVerifier() (string, error) {
+ buf := make([]byte, 32)
+ if _, err := rand.Read(buf); err != nil {
+ return "", err
+ }
+ return base64.RawURLEncoding.EncodeToString(buf), nil
+}
+
+func sha256Base64(verifier string) string {
+ sum := sha256.Sum256([]byte(verifier))
+ return base64.RawURLEncoding.EncodeToString(sum[:])
+}
+
+func needsRefresh(creds *types.OauthCreds) bool {
+ // refresh an hour early so we can make multiple calls before it expires
+ return time.Now().After(creds.ExpiresAt.Add(-1 * time.Hour))
+}
+
+func refreshCreds(accountCreds *types.AccountCredentials) (*types.OauthCreds, int, error) {
+ creds := accountCreds.ClaudeMax
+ if creds == nil {
+ return nil, 0, fmt.Errorf("no stored Claude credentials")
+ }
+
+ body, err := json.Marshal(map[string]any{
+ "grant_type": "refresh_token",
+ "refresh_token": creds.RefreshToken,
+ "client_id": claudeMaxClientId,
+ })
+ if err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - marshal: %w", err)
+ }
+
+ req, err := http.NewRequest("POST", claudeMaxTokenUrl, bytes.NewReader(body))
+ if err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - create request: %w", err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("anthropic-beta", shared.AnthropicClaudeMaxBetaHeader)
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - http: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ b, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - read body: %w", err)
+ }
+ return nil, resp.StatusCode, fmt.Errorf("refresh failed - status %d: %s", resp.StatusCode, b)
+ }
+
+ var r types.OauthResponse
+ if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - decode: %w", err)
+ }
+
+ newCreds := &types.OauthCreds{
+ OauthResponse: r,
+ ExpiresAt: time.Now().Add(time.Duration(r.ExpiresIn) * time.Second),
+ }
+
+ // persist updated creds
+ accountCreds.ClaudeMax = newCreds
+ if err := SetAccountCredentials(accountCreds); err != nil {
+ return nil, 0, fmt.Errorf("refresh failed - save: %w", err)
+ }
+
+ return newCreds, resp.StatusCode, nil
+}
diff --git a/app/cli/lib/model_credentials.go b/app/cli/lib/model_credentials.go
index a21d12eb..4b266ab6 100644
--- a/app/cli/lib/model_credentials.go
+++ b/app/cli/lib/model_credentials.go
@@ -3,10 +3,15 @@ package lib
import (
"context"
"encoding/base64"
+ "encoding/json"
"fmt"
"os"
+ "path/filepath"
"plandex-cli/api"
+ "plandex-cli/auth"
+ "plandex-cli/fs"
"plandex-cli/term"
+ "plandex-cli/types"
shared "plandex-shared"
"sort"
"strings"
@@ -41,7 +46,7 @@ type CredentialCheckResult struct {
AuthVars map[string]string
}
-func CheckCredentialStatus(opts shared.ModelProviderOptions) CredentialCheckResult {
+func CheckCredentialStatus(opts shared.ModelProviderOptions, claudeMaxEnabled bool) (CredentialCheckResult, error) {
publishersToProviders := groupProvidersByPublisher(opts)
selectedAuthVars := map[string]string{}
@@ -53,8 +58,18 @@ func CheckCredentialStatus(opts shared.ModelProviderOptions) CredentialCheckResu
partialProviders := []ProviderCredentialStatus{}
for _, provider := range providers {
- authVars, _ := ResolveProviderAuthVars(provider.Config)
- status, missingVars := checkProviderCredentialStatus(provider.Config, authVars)
+ if provider.Config.HasClaudeMaxAuth && !claudeMaxEnabled {
+ continue
+ }
+
+ authVars, err := ResolveProviderAuthVars(provider.Config)
+ if err != nil {
+ return CredentialCheckResult{}, fmt.Errorf("error checking API keys/credentials: %v", err)
+ }
+ status, missingVars, err := checkProviderCredentialStatus(provider.Config, authVars)
+ if err != nil {
+ return CredentialCheckResult{}, fmt.Errorf("error checking API keys/credentials: %v", err)
+ }
providerStatus := ProviderCredentialStatus{
ProviderComposite: provider.Config.ToComposite(),
@@ -87,7 +102,7 @@ func CheckCredentialStatus(opts shared.ModelProviderOptions) CredentialCheckResu
AllSatisfied: allSatisfied,
Publishers: publisherStatuses,
AuthVars: selectedAuthVars,
- }
+ }, nil
}
func groupProvidersByPublisher(opts shared.ModelProviderOptions) map[shared.ModelPublisher][]shared.ModelProviderOption {
@@ -106,11 +121,21 @@ func groupProvidersByPublisher(opts shared.ModelProviderOptions) map[shared.Mode
return grouped
}
-func checkProviderCredentialStatus(cfg *shared.ModelProviderConfigSchema, authVars map[string]string) (ProviderAuthStatus, []string) {
+func checkProviderCredentialStatus(cfg *shared.ModelProviderConfigSchema, authVars map[string]string) (ProviderAuthStatus, []string, error) {
var missing []string
if cfg.SkipAuth {
- return FullySatisfied, nil
+ return FullySatisfied, nil, nil
+ }
+
+ if cfg.HasClaudeMaxAuth {
+ creds, err := GetAccountCredentials()
+ if err != nil {
+ return FullyMissing, nil, fmt.Errorf("error getting account credentials: %v", err)
+ }
+ if creds == nil || creds.ClaudeMax == nil {
+ return FullyMissing, nil, nil
+ }
}
if cfg.ApiKeyEnvVar != "" && authVars[cfg.ApiKeyEnvVar] == "" {
@@ -135,11 +160,11 @@ func checkProviderCredentialStatus(cfg *shared.ModelProviderConfigSchema, authVa
switch {
case len(missing) == 0:
- return FullySatisfied, nil
+ return FullySatisfied, nil, nil
case len(missing) == numRequired:
- return FullyMissing, missing
+ return FullyMissing, missing, nil
default:
- return PartiallySatisfied, missing
+ return PartiallySatisfied, missing, nil
}
}
@@ -155,19 +180,33 @@ func mustVerifyAuthVars(silent bool) map[string]string {
if !silent {
term.StartSpinner("")
}
- planSettings, apiErr := api.Client.GetSettings(CurrentPlanId, CurrentBranch)
- if !silent {
- term.StopSpinner()
- }
+ planSettings, apiErr := api.Client.GetSettings(CurrentPlanId, CurrentBranch)
if apiErr != nil {
- term.OutputErrorAndExit("Error getting current settings: %v", apiErr)
+ term.OutputErrorAndExit("Error getting settings: %v", apiErr)
}
+ orgUserConfig := MustGetOrgUserConfig()
+
opts := planSettings.GetModelProviderOptions()
- checkResult := CheckCredentialStatus(opts)
+ if !silent {
+ if hasAnthropicModels(opts) {
+ didConnect := promptClaudeMaxIfNeeded()
+ term.StartSpinner("")
+ if !didConnect && orgUserConfig.UseClaudeSubscription {
+ didConnect = connectClaudeMaxIfNeeded()
+ if !didConnect {
+ refreshClaudeMaxCredsIfNeeded()
+ }
+ }
+ }
+ }
+ checkResult, err := CheckCredentialStatus(opts, orgUserConfig.UseClaudeSubscription)
+ if err != nil {
+ term.OutputErrorAndExit("Error checking API keys/credentials: %v", err)
+ }
if checkResult.AllSatisfied {
return checkResult.AuthVars
}
@@ -199,6 +238,18 @@ func ResolveProviderAuthVars(cfg *shared.ModelProviderConfigSchema) (map[string]
// because we're disabling the EC2 metadata service, the aws check will fail unless appropriate env vars or credentials file is found, but it's not actually a problem—just indicates AWS creds aren't set
}
+ if cfg.HasClaudeMaxAuth {
+ creds, err := GetAccountCredentials()
+ if err != nil {
+ return nil, fmt.Errorf("error getting account credentials: %v", err)
+ }
+
+ if creds != nil && creds.ClaudeMax != nil {
+ token := creds.ClaudeMax.AccessToken
+ authVars[shared.AnthropicClaudeMaxTokenEnvVar] = token
+ }
+ }
+
if cfg.ApiKeyEnvVar != "" {
val := os.Getenv(cfg.ApiKeyEnvVar)
if val != "" {
@@ -481,3 +532,58 @@ func mark(ok bool) string {
}
return "❌"
}
+
+var cachedAccountCredentials *types.AccountCredentials
+
+func SetAccountCredentials(creds *types.AccountCredentials) error {
+ if auth.Current == nil {
+ return fmt.Errorf("no authenticated user")
+ }
+ dir := filepath.Join(fs.HomePlandexDir, auth.Current.UserId, auth.Current.OrgId)
+ err := os.MkdirAll(dir, 0700)
+ if err != nil {
+ return fmt.Errorf("error creating account credentials directory: %v", err)
+ }
+ path := filepath.Join(dir, "creds.json")
+ bytes, err := json.MarshalIndent(creds, "", " ")
+ if err != nil {
+ return fmt.Errorf("error marshalling account credentials: %v", err)
+ }
+ err = os.WriteFile(path, bytes, 0600)
+ if err != nil {
+ return fmt.Errorf("error writing account credentials: %v", err)
+ }
+
+ cachedAccountCredentials = creds
+
+ return nil
+}
+
+func GetAccountCredentials() (*types.AccountCredentials, error) {
+ if cachedAccountCredentials != nil {
+ return cachedAccountCredentials, nil
+ }
+
+ if auth.Current == nil {
+ return nil, fmt.Errorf("no authenticated user")
+ }
+ path := filepath.Join(fs.HomePlandexDir, auth.Current.UserId, auth.Current.OrgId, "creds.json")
+
+ bytes, err := os.ReadFile(path)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return nil, nil
+ }
+ return nil, err
+ }
+
+ var creds types.AccountCredentials
+ err = json.Unmarshal(bytes, &creds)
+ if err != nil {
+ return nil, err
+ }
+
+ cachedAccountCredentials = &creds
+
+ return &creds, nil
+}
diff --git a/app/cli/lib/org_user_config.go b/app/cli/lib/org_user_config.go
new file mode 100644
index 00000000..3a8a2309
--- /dev/null
+++ b/app/cli/lib/org_user_config.go
@@ -0,0 +1,35 @@
+package lib
+
+import (
+ "plandex-cli/api"
+ "plandex-cli/term"
+
+ shared "plandex-shared"
+)
+
+var cachedOrgUserConfig *shared.OrgUserConfig
+
+func MustGetOrgUserConfig() *shared.OrgUserConfig {
+ if cachedOrgUserConfig != nil {
+ return cachedOrgUserConfig
+ }
+
+ orgUserConfig, err := api.Client.GetOrgUserConfig()
+ if err != nil {
+ term.OutputErrorAndExit("Error getting org user config: %v", err)
+ }
+ cachedOrgUserConfig = orgUserConfig
+ return orgUserConfig
+}
+
+func MustUpdateOrgUserConfig(orgUserConfig shared.OrgUserConfig) {
+ err := api.Client.UpdateOrgUserConfig(orgUserConfig)
+ if err != nil {
+ term.OutputErrorAndExit("Error updating org user config: %v", err)
+ }
+ SetCachedOrgUserConfig(&orgUserConfig)
+}
+
+func SetCachedOrgUserConfig(orgUserConfig *shared.OrgUserConfig) {
+ cachedOrgUserConfig = orgUserConfig
+}
diff --git a/app/cli/lib/plan_config.go b/app/cli/lib/plan_config.go
index bb4731ae..0792e240 100644
--- a/app/cli/lib/plan_config.go
+++ b/app/cli/lib/plan_config.go
@@ -2,6 +2,8 @@ package lib
import (
"os"
+ "plandex-cli/api"
+ "plandex-cli/term"
"sort"
shared "plandex-shared"
@@ -9,6 +11,25 @@ import (
"github.com/olekukonko/tablewriter"
)
+var cachedPlanConfig *shared.PlanConfig
+
+func MustGetCurrentPlanConfig() *shared.PlanConfig {
+ if cachedPlanConfig != nil {
+ return cachedPlanConfig
+ }
+
+ planConfig, apiErr := api.Client.GetPlanConfig(CurrentPlanId)
+ if apiErr != nil {
+ term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
+ }
+ cachedPlanConfig = planConfig
+ return planConfig
+}
+
+func SetCachedPlanConfig(planConfig *shared.PlanConfig) {
+ cachedPlanConfig = planConfig
+}
+
func ShowPlanConfig(config *shared.PlanConfig, key string) {
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoWrapText(true)
diff --git a/app/cli/plan_exec/apply_exec.go b/app/cli/plan_exec/apply_exec.go
index 4f332429..80b82259 100644
--- a/app/cli/plan_exec/apply_exec.go
+++ b/app/cli/plan_exec/apply_exec.go
@@ -84,6 +84,8 @@ func getOnApplyExecFail(applyFlags types.ApplyFlags, tellFlags types.TellFlags,
term.OutputErrorAndExit("failed to update plan config: %s", apiErr)
}
+ lib.SetCachedPlanConfig(config)
+
applyFlags.AutoCommit = true
applyFlags.AutoConfirm = true
applyFlags.AutoExec = true
diff --git a/app/cli/term/help.go b/app/cli/term/help.go
index 11b23b30..a2c5c684 100644
--- a/app/cli/term/help.go
+++ b/app/cli/term/help.go
@@ -146,6 +146,9 @@ var CliCommands = []CmdConfig{
{"revoke", "", "revoke an invite or remove a user from your org", true},
{"users", "", "list users and pending invites in your org", true},
+ {"connect-claude", "", "connect your Claude Pro or Max subscription", true},
+ {"disconnect-claude", "", "disconnect your Claude Pro or Max subscription", true},
+
{"usage", "", "show Plandex Cloud current balance and usage report", true},
{"usage --today", "", "show Plandex Cloud usage for the day so far", true},
{"usage --month", "", "show Plandex Cloud usage for the current billing month", true},
@@ -345,6 +348,10 @@ func PrintHelpAllCommands() {
printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "sign-in", "invite", "revoke", "users")
fmt.Fprintln(builder)
+ color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Integrations ")
+ printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "connect-claude", "disconnect-claude")
+ fmt.Fprintln(builder)
+
color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Cloud ")
printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "usage", "usage --today", "usage --month", "usage --plan", "usage --log", "billing")
fmt.Fprintln(builder)
@@ -355,3 +362,13 @@ func PrintHelpAllCommands() {
fmt.Print(builder.String())
}
+
+func ShowCmd(cmd string) string {
+ if IsRepl {
+ cmd = fmt.Sprintf("\\%s", cmd)
+ } else {
+ cmd = fmt.Sprintf("plandex %s", cmd)
+ }
+
+ return color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprintf(" %s ", cmd)
+}
diff --git a/app/cli/term/prompt.go b/app/cli/term/prompt.go
index 65a44500..22895382 100644
--- a/app/cli/term/prompt.go
+++ b/app/cli/term/prompt.go
@@ -29,6 +29,9 @@ func GetUserStringInput(msg string) (string, error) {
}
func GetUserStringInputWithDefault(msg, def string) (string, error) {
+ disableBracketedPaste()
+ defer enableBracketedPaste()
+
res, err := prompt.New().Ask(msg).Input(def)
if err != nil && err.Error() == "user quit prompt" {
@@ -53,6 +56,9 @@ func GetRequiredUserStringInputWithDefault(msg, def string) (string, error) {
}
func GetUserPasswordInput(msg string) (string, error) {
+ disableBracketedPaste()
+ defer enableBracketedPaste()
+
res, err := prompt.New().Ask(msg).Input("", input.WithEchoMode(input.EchoPassword))
if err != nil && err.Error() == "user quit prompt" {
@@ -131,3 +137,11 @@ func ConfirmYesNoCancel(fmtStr string, fmtArgs ...interface{}) (bool, bool, erro
return ConfirmYesNoCancel(fmtStr, fmtArgs...)
}
}
+
+func disableBracketedPaste() {
+ fmt.Print("\033[?2004l")
+}
+
+func enableBracketedPaste() {
+ fmt.Print("\033[?2004h")
+}
diff --git a/app/cli/types/api.go b/app/cli/types/api.go
index 90c0bcdc..92ee096d 100644
--- a/app/cli/types/api.go
+++ b/app/cli/types/api.go
@@ -31,6 +31,9 @@ type ApiClient interface {
ListOrgs() ([]*shared.Org, *shared.ApiError)
CreateOrg(req shared.CreateOrgRequest) (*shared.CreateOrgResponse, *shared.ApiError)
+ GetOrgUserConfig() (*shared.OrgUserConfig, *shared.ApiError)
+ UpdateOrgUserConfig(req shared.OrgUserConfig) *shared.ApiError
+
ListUsers() (*shared.ListUsersResponse, *shared.ApiError)
DeleteUser(userId string) *shared.ApiError
diff --git a/app/cli/types/types.go b/app/cli/types/types.go
index c32e5460..e4a27e91 100644
--- a/app/cli/types/types.go
+++ b/app/cli/types/types.go
@@ -2,6 +2,7 @@ package types
import (
shared "plandex-shared"
+ "time"
"github.com/sashabaranov/go-openai"
)
@@ -67,3 +68,18 @@ type ChangesUIViewportsUpdate struct {
}
type OnErrFn func(errMsg string, errArgs ...interface{})
+
+type OauthResponse struct {
+ AccessToken string `json:"access_token"`
+ RefreshToken string `json:"refresh_token"`
+ ExpiresIn int `json:"expires_in"`
+}
+
+type OauthCreds struct {
+ OauthResponse
+ ExpiresAt time.Time `json:"expires_at"`
+}
+
+type AccountCredentials struct {
+ ClaudeMax *OauthCreds `json:"claudeMax"`
+}
diff --git a/app/scripts/dev.sh b/app/scripts/dev.sh
index 7606bace..8af6d230 100755
--- a/app/scripts/dev.sh
+++ b/app/scripts/dev.sh
@@ -51,7 +51,7 @@ export LOCAL_MODE=1
reflex -r '^(cli|shared)/.*\.(go|mod|sum)$' -- sh -c 'cd cli && ./dev.sh' &
pid1=$!
-reflex -r '^(server|shared)/.*\.(go|mod|sum)$' -s -- sh -c 'cd server && go build && ./plandex-server' &
+reflex -r '^(server|shared)/.*\.(go|mod|sum|py)$' -s -- sh -c 'cd server && go build && ./plandex-server' &
pid2=$!
wait $pid1
diff --git a/app/server/db/data_models.go b/app/server/db/data_models.go
index dedc4931..b9053905 100644
--- a/app/server/db/data_models.go
+++ b/app/server/db/data_models.go
@@ -95,12 +95,13 @@ func (invite *Invite) ToApi() *shared.Invite {
}
type OrgUser struct {
- Id string `db:"id"`
- OrgId string `db:"org_id"`
- OrgRoleId string `db:"org_role_id"`
- UserId string `db:"user_id"`
- CreatedAt time.Time `db:"created_at"`
- UpdatedAt time.Time `db:"updated_at"`
+ Id string `db:"id"`
+ OrgId string `db:"org_id"`
+ OrgRoleId string `db:"org_role_id"`
+ UserId string `db:"user_id"`
+ Config *shared.OrgUserConfig `db:"config"`
+ CreatedAt time.Time `db:"created_at"`
+ UpdatedAt time.Time `db:"updated_at"`
}
func (orgUser *OrgUser) ToApi() *shared.OrgUser {
@@ -108,6 +109,7 @@ func (orgUser *OrgUser) ToApi() *shared.OrgUser {
OrgId: orgUser.OrgId,
OrgRoleId: orgUser.OrgRoleId,
UserId: orgUser.UserId,
+ Config: orgUser.Config,
}
}
diff --git a/app/server/db/db.go b/app/server/db/db.go
index 2d9b591a..d6c72652 100644
--- a/app/server/db/db.go
+++ b/app/server/db/db.go
@@ -127,7 +127,7 @@ func migrationsUp(dir string) error {
// Uncomment below (and update migration version) to reset migration state to a specific version after a failure
// if os.Getenv("GOENV") == "development" {
- // migrateVersion := 2025051600
+ // migrateVersion := 2025052900
// if err := m.Force(migrateVersion); err != nil {
// return fmt.Errorf("error forcing migration version: %v", err)
// }
diff --git a/app/server/db/user_helpers.go b/app/server/db/user_helpers.go
index c41b0765..a6ae6e54 100644
--- a/app/server/db/user_helpers.go
+++ b/app/server/db/user_helpers.go
@@ -3,6 +3,7 @@ package db
import (
"database/sql"
"fmt"
+ shared "plandex-shared"
"strings"
"github.com/jmoiron/sqlx"
@@ -69,6 +70,31 @@ func GetOrgUser(userId, orgId string) (*OrgUser, error) {
return &orgUser, nil
}
+func GetOrgUserConfig(userId, orgId string) (*shared.OrgUserConfig, error) {
+ var orgUserConfig shared.OrgUserConfig
+ err := Conn.Get(&orgUserConfig, "SELECT config FROM orgs_users WHERE user_id = $1 AND org_id = $2", userId, orgId)
+
+ if err != nil {
+ if err == sql.ErrNoRows {
+ return nil, nil
+ }
+
+ return nil, fmt.Errorf("error getting org user config: %v", err)
+ }
+
+ return &orgUserConfig, nil
+}
+
+func UpdateOrgUserConfig(userId, orgId string, config *shared.OrgUserConfig) error {
+ _, err := Conn.Exec("UPDATE orgs_users SET config = $1 WHERE user_id = $2 AND org_id = $3", config, userId, orgId)
+
+ if err != nil {
+ return fmt.Errorf("error updating org user config: %v", err)
+ }
+
+ return nil
+}
+
func ListOrgUsers(orgId string) ([]*OrgUser, error) {
var orgUsers []*OrgUser
err := Conn.Select(&orgUsers, "SELECT * FROM orgs_users WHERE org_id = $1", orgId)
diff --git a/app/server/handlers/client_helper.go b/app/server/handlers/client_helper.go
index dd3839f3..0823a94a 100644
--- a/app/server/handlers/client_helper.go
+++ b/app/server/handlers/client_helper.go
@@ -20,8 +20,9 @@ type initClientsParams struct {
authVars map[string]string
- plan *db.Plan
- settings *shared.PlanSettings
+ plan *db.Plan
+ settings *shared.PlanSettings
+ orgUserConfig *shared.OrgUserConfig
}
type initClientsResult struct {
@@ -32,6 +33,7 @@ type initClientsResult struct {
func initClients(params initClientsParams) initClientsResult {
w := params.w
settings := params.settings
+ orgUserConfig := params.orgUserConfig
var authVars map[string]string
if params.authVars != nil {
@@ -66,7 +68,7 @@ func initClients(params initClientsParams) initClientsResult {
return initClientsResult{}
}
- clients := model.InitClients(authVars, settings)
+ clients := model.InitClients(authVars, settings, orgUserConfig)
return initClientsResult{
clients: clients,
diff --git a/app/server/handlers/context_helper.go b/app/server/handlers/context_helper.go
index a4ef5b89..6ab41954 100644
--- a/app/server/handlers/context_helper.go
+++ b/app/server/handlers/context_helper.go
@@ -90,6 +90,7 @@ func loadContexts(
var settings *shared.PlanSettings
var clients map[string]model.ClientInfo
var authVars map[string]string
+ var orgUserConfig *shared.OrgUserConfig
for _, context := range *loadReq {
if context.ContextType == shared.ContextPipedDataType || context.ContextType == shared.ContextNoteType || context.ContextType == shared.ContextImageType {
@@ -102,6 +103,13 @@ func loadContexts(
return nil, nil
}
+ orgUserConfig, err = db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ http.Error(w, "Error getting org user config: "+err.Error(), http.StatusInternalServerError)
+ return nil, nil
+ }
+
res := initClients(
initClientsParams{
w: w,
@@ -149,14 +157,15 @@ func loadContexts(
}()
name, err := model.GenPipedDataName(model.GenPipedDataNameParams{
- Ctx: r.Context(),
- Auth: auth,
- Plan: plan,
- Settings: settings,
- AuthVars: authVars,
- SessionId: context.SessionId,
- Clients: clients,
- PipedContent: context.Body,
+ Ctx: r.Context(),
+ Auth: auth,
+ Plan: plan,
+ Settings: settings,
+ AuthVars: authVars,
+ SessionId: context.SessionId,
+ Clients: clients,
+ PipedContent: context.Body,
+ OrgUserConfig: orgUserConfig,
})
if err != nil {
@@ -179,7 +188,7 @@ func loadContexts(
}
}()
- name, err := model.GenNoteName(r.Context(), auth, plan, settings, clients, authVars, context.Body, context.SessionId)
+ name, err := model.GenNoteName(r.Context(), auth, plan, settings, orgUserConfig, clients, authVars, context.Body, context.SessionId)
if err != nil {
errCh <- fmt.Errorf("error generating name for note: %v", err)
diff --git a/app/server/handlers/plans_exec.go b/app/server/handlers/plans_exec.go
index f0574b21..8f9c6fde 100644
--- a/app/server/handlers/plans_exec.go
+++ b/app/server/handlers/plans_exec.go
@@ -76,15 +76,23 @@ func TellPlanHandler(w http.ResponseWriter, r *http.Request) {
return
}
+ orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ http.Error(w, "Error getting org user config", http.StatusInternalServerError)
+ return
+ }
+
res := initClients(
initClientsParams{
- w: w,
- auth: auth,
- apiKeys: requestBody.ApiKeys,
- openAIOrgId: requestBody.OpenAIOrgId,
- authVars: requestBody.AuthVars,
- plan: plan,
- settings: settings,
+ w: w,
+ auth: auth,
+ apiKeys: requestBody.ApiKeys,
+ openAIOrgId: requestBody.OpenAIOrgId,
+ authVars: requestBody.AuthVars,
+ plan: plan,
+ settings: settings,
+ orgUserConfig: orgUserConfig,
},
)
err = modelPlan.Tell(modelPlan.TellParams{
@@ -154,24 +162,34 @@ func BuildPlanHandler(w http.ResponseWriter, r *http.Request) {
return
}
+ orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ http.Error(w, "Error getting org user config", http.StatusInternalServerError)
+ return
+ }
+
res := initClients(
initClientsParams{
- w: w,
- auth: auth,
- apiKeys: requestBody.ApiKeys,
- openAIOrgId: requestBody.OpenAIOrgId,
- authVars: requestBody.AuthVars,
- plan: plan,
- settings: settings,
+ w: w,
+ auth: auth,
+ apiKeys: requestBody.ApiKeys,
+ openAIOrgId: requestBody.OpenAIOrgId,
+ authVars: requestBody.AuthVars,
+ plan: plan,
+ settings: settings,
+ orgUserConfig: orgUserConfig,
},
)
numBuilds, err := modelPlan.Build(modelPlan.BuildParams{
- Clients: res.clients,
- AuthVars: res.authVars,
- Plan: plan,
- Branch: branch,
- Auth: auth,
- SessionId: requestBody.SessionId,
+ Clients: res.clients,
+ AuthVars: res.authVars,
+ Plan: plan,
+ Branch: branch,
+ Auth: auth,
+ SessionId: requestBody.SessionId,
+ OrgUserConfig: orgUserConfig,
+ Settings: settings,
})
if err != nil {
diff --git a/app/server/handlers/sessions.go b/app/server/handlers/sessions.go
index 5501df3d..ba6ba6bd 100644
--- a/app/server/handlers/sessions.go
+++ b/app/server/handlers/sessions.go
@@ -283,3 +283,64 @@ func SignOutHandler(w http.ResponseWriter, r *http.Request) {
log.Println("Successfully signed out")
}
+
+func GetOrgUserConfigHandler(w http.ResponseWriter, r *http.Request) {
+ log.Println("Received request for GetOrgUserConfigHandler")
+
+ auth := Authenticate(w, r, true)
+ if auth == nil {
+ return
+ }
+
+ orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ http.Error(w, "Error getting org user config: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ bytes, err := json.Marshal(orgUserConfig)
+
+ if err != nil {
+ log.Printf("Error marshalling response: %v\n", err)
+ http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ w.Write(bytes)
+}
+
+func UpdateOrgUserConfigHandler(w http.ResponseWriter, r *http.Request) {
+ log.Println("Received request for UpdateOrgUserConfigHandler")
+
+ auth := Authenticate(w, r, true)
+ if auth == nil {
+ return
+ }
+
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ log.Printf("Error reading request body: %v\n", err)
+ http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ var req shared.OrgUserConfig
+ err = json.Unmarshal(body, &req)
+ if err != nil {
+ log.Printf("Error unmarshalling request: %v\n", err)
+ http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ err = db.UpdateOrgUserConfig(auth.User.Id, auth.OrgId, &req)
+
+ if err != nil {
+ log.Printf("Error updating org user config: %v\n", err)
+ http.Error(w, "Error updating org user config: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ log.Println("Successfully updated org user config")
+}
diff --git a/app/server/litellm_proxy.py b/app/server/litellm_proxy.py
index fac5e669..a1f41190 100644
--- a/app/server/litellm_proxy.py
+++ b/app/server/litellm_proxy.py
@@ -1,12 +1,57 @@
+from litellm.llms.anthropic.common_utils import AnthropicModelInfo
+from typing import List, Optional
+
+_orig_get_hdrs = AnthropicModelInfo.get_anthropic_headers
+
+def _oauth_get_hdrs(
+ self,
+ api_key: str,
+ anthropic_version: Optional[str] = None,
+ computer_tool_used: bool = False,
+ prompt_caching_set: bool = False,
+ pdf_used: bool = False,
+ file_id_used: bool = False,
+ mcp_server_used: bool = False,
+ is_vertex_request: bool = False,
+ user_anthropic_beta_headers: Optional[List[str]] = None,
+):
+ # call the original builder first
+ hdrs = _orig_get_hdrs(
+ self,
+ api_key=api_key,
+ anthropic_version=anthropic_version,
+ computer_tool_used=computer_tool_used,
+ prompt_caching_set=prompt_caching_set,
+ pdf_used=pdf_used,
+ file_id_used=file_id_used,
+ mcp_server_used=mcp_server_used,
+ is_vertex_request=is_vertex_request,
+ user_anthropic_beta_headers=user_anthropic_beta_headers,
+ )
+
+ # remove x-api-key when we detect an OAuth access-token
+ print(f"api_key: {api_key}")
+ if api_key and api_key.startswith(("sk-ant-oat", "sk-ant-oau")):
+ hdrs["anthropic-beta"] = "oauth-2025-04-20"
+ hdrs["anthropic-product"] = "claude-code"
+ hdrs.pop("x-api-key", None)
+
+ print(f"Anthropic headers: {hdrs}")
+
+ return hdrs
+
+# monkey-patch AnthropicModelInfo.get_anthropic_headers to handle OAuth headers
+AnthropicModelInfo.get_anthropic_headers = _oauth_get_hdrs
+
from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse, JSONResponse
from litellm import completion, _turn_on_debug
import json
import re
-# _turn_on_debug()
+_turn_on_debug()
-LOGGING_ENABLED = False
+LOGGING_ENABLED = True
print("Litellm proxy: starting proxy server on port 4000...")
diff --git a/app/server/migrations/2025051600_custom_models_refactor.up.sql b/app/server/migrations/2025051600_custom_models_refactor.up.sql
index 6fbb1b03..664b7d4b 100644
--- a/app/server/migrations/2025051600_custom_models_refactor.up.sql
+++ b/app/server/migrations/2025051600_custom_models_refactor.up.sql
@@ -87,7 +87,7 @@ SELECT
created_at, updated_at
FROM custom_models_legacy
-ON CONFLICT (id) DO NOTHING;
+ON CONFLICT (org_id, model_id) DO NOTHING;
/* ---- migrate unique custom providers ------------------------------- */
WITH src AS (
diff --git a/app/server/migrations/2025070200_add_org_user_config.down.sql b/app/server/migrations/2025070200_add_org_user_config.down.sql
new file mode 100644
index 00000000..3f47b04a
--- /dev/null
+++ b/app/server/migrations/2025070200_add_org_user_config.down.sql
@@ -0,0 +1 @@
+ALTER TABLE orgs_users DROP COLUMN config;
\ No newline at end of file
diff --git a/app/server/migrations/2025070200_add_org_user_config.up.sql b/app/server/migrations/2025070200_add_org_user_config.up.sql
new file mode 100644
index 00000000..ced7ad55
--- /dev/null
+++ b/app/server/migrations/2025070200_add_org_user_config.up.sql
@@ -0,0 +1 @@
+ALTER TABLE orgs_users ADD COLUMN config JSON;
\ No newline at end of file
diff --git a/app/server/model/client.go b/app/server/model/client.go
index 44343efe..f201a3c1 100644
--- a/app/server/model/client.go
+++ b/app/server/model/client.go
@@ -10,6 +10,7 @@ import (
"log"
"net/http"
"os"
+ "plandex-server/db"
"plandex-server/types"
"strings"
"sync"
@@ -42,9 +43,9 @@ type ClientInfo struct {
OpenAIOrgId string
}
-func InitClients(authVars map[string]string, settings *shared.PlanSettings) map[string]ClientInfo {
+func InitClients(authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig) map[string]ClientInfo {
clients := make(map[string]ClientInfo)
- providers := shared.GetProvidersForAuthVars(authVars, settings)
+ providers := shared.GetProvidersForAuthVars(authVars, settings, orgUserConfig)
for _, provider := range providers {
clients[provider.ToComposite()] = newClient(provider, authVars)
@@ -57,6 +58,8 @@ func newClient(providerConfig shared.ModelProviderConfigSchema, authVars map[str
var apiKey string
if providerConfig.ApiKeyEnvVar != "" {
apiKey = authVars[providerConfig.ApiKeyEnvVar]
+ } else if providerConfig.HasClaudeMaxAuth {
+ apiKey = authVars[shared.AnthropicClaudeMaxTokenEnvVar]
}
config := openai.DefaultConfig(apiKey)
@@ -106,16 +109,19 @@ func CreateChatCompletionStream(
authVars map[string]string,
modelConfig *shared.ModelRoleConfig,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
+ currentOrgId string,
+ currentUserId string,
ctx context.Context,
req types.ExtendedChatCompletionRequest,
) (*ExtendedChatCompletionStream, error) {
- providerComposite := modelConfig.GetProviderComposite(authVars, settings)
+ providerComposite := modelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
_, ok := clients[providerComposite]
if !ok {
return nil, fmt.Errorf("client not found for provider composite: %s", providerComposite)
}
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
// ensure the model name is set correctly on fallbacks
req.Model = baseModelConfig.ModelName
@@ -146,16 +152,18 @@ func CreateChatCompletionStream(
}
return withStreamingRetries(ctx, func(numTotalRetry int, didProviderFallback bool, modelErr *shared.ModelError) (*ExtendedChatCompletionStream, shared.FallbackResult, error) {
- fallbackRes := modelConfig.GetFallbackForModelError(numTotalRetry, didProviderFallback, modelErr, authVars, settings)
+ handleClaudeMaxRateLimitedIfNeeded(modelErr, modelConfig, authVars, settings, orgUserConfig, currentOrgId, currentUserId)
+
+ fallbackRes := modelConfig.GetFallbackForModelError(numTotalRetry, didProviderFallback, modelErr, authVars, settings, orgUserConfig)
resolvedModelConfig := fallbackRes.ModelRoleConfig
if resolvedModelConfig == nil {
return nil, fallbackRes, fmt.Errorf("model config is nil")
}
- providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings)
+ providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
- baseModelConfig := resolvedModelConfig.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := resolvedModelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
opClient, ok := clients[providerComposite]
@@ -185,7 +193,7 @@ func CreateChatCompletionStream(
"modelConfig.ApiKeyEnvVar": baseModelConfig.ApiKeyEnvVar,
})
- resp, err := createChatCompletionStreamExtended(resolvedModelConfig, opClient, authVars, settings, ctx, req)
+ resp, err := createChatCompletionStreamExtended(resolvedModelConfig, opClient, authVars, settings, orgUserConfig, ctx, req)
return resp, fallbackRes, err
}, func(resp *ExtendedChatCompletionStream, err error) {})
}
@@ -195,10 +203,11 @@ func createChatCompletionStreamExtended(
client ClientInfo,
authVars map[string]string,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
ctx context.Context,
extendedReq types.ExtendedChatCompletionRequest,
) (*ExtendedChatCompletionStream, error) {
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
// ensure the model name is set correctly on fallbacks
extendedReq.Model = baseModelConfig.ModelName
@@ -273,6 +282,26 @@ func createChatCompletionStreamExtended(
}
}
+ if client.ProviderConfig.HasClaudeMaxAuth {
+ extendedReq.Messages = append([]types.ExtendedChatMessage{
+ {
+ Role: openai.ChatMessageRoleSystem,
+ Content: []types.ExtendedChatMessagePart{
+ {Type: openai.ChatMessagePartTypeText,
+ Text: "You are Claude Code, Anthropic's official CLI for Claude."},
+ },
+ },
+ }, extendedReq.Messages...)
+
+ if extendedReq.ExtraHeaders == nil {
+ extendedReq.ExtraHeaders = make(map[string]string)
+ }
+ extendedReq.ExtraHeaders["anthropic-beta"] = shared.AnthropicClaudeMaxBetaHeader
+ extendedReq.ExtraHeaders["Authorization"] = "Bearer " + authVars[shared.AnthropicClaudeMaxTokenEnvVar]
+ extendedReq.ExtraHeaders["anthropic-product"] = "claude-code"
+
+ }
+
// Marshal the request body to JSON
var jsonBody []byte
var err error
@@ -495,3 +524,22 @@ func addOpenRouterHeaders(req *http.Request) {
req.Header.Set("X-OR-Region", "us-east-1")
}
}
+
+func handleClaudeMaxRateLimitedIfNeeded(modelErr *shared.ModelError, modelConfig *shared.ModelRoleConfig, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, currentOrgId string, currentUserId string) {
+
+ // if we used a claude max provider and got rate limited, set the cooldown on org user config and update the db in the background
+ if modelErr != nil && modelErr.Kind == shared.ErrRateLimited && modelErr.RetryAfterSeconds == 0 {
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
+ if baseModelConfig.BaseModelProviderConfig.HasClaudeMaxAuth {
+ orgUserConfig.ClaudeSubscriptionCooldownStartedAt = time.Now()
+
+ go func() {
+ err := db.UpdateOrgUserConfig(currentUserId, currentOrgId, orgUserConfig)
+ if err != nil {
+ log.Printf("Error updating org user config: %v\n", err)
+ }
+ }()
+ }
+ }
+
+}
diff --git a/app/server/model/client_stream.go b/app/server/model/client_stream.go
index 6bf5467f..dccdee6a 100644
--- a/app/server/model/client_stream.go
+++ b/app/server/model/client_stream.go
@@ -21,18 +21,21 @@ func CreateChatCompletionWithInternalStream(
authVars map[string]string,
modelConfig *shared.ModelRoleConfig,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
+ currentOrgId string,
+ currentUserId string,
ctx context.Context,
req types.ExtendedChatCompletionRequest,
onStream OnStreamFn,
reqStarted time.Time,
) (*types.ModelResponse, error) {
- providerComposite := modelConfig.GetProviderComposite(authVars, settings)
+ providerComposite := modelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
_, ok := clients[providerComposite]
if !ok {
return nil, fmt.Errorf("client not found for provider composite: %s", providerComposite)
}
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
resolveReq(&req, modelConfig, baseModelConfig, settings)
@@ -50,14 +53,16 @@ func CreateChatCompletionWithInternalStream(
}
return withStreamingRetries(ctx, func(numTotalRetry int, didProviderFallback bool, modelErr *shared.ModelError) (resp *types.ModelResponse, fallbackRes shared.FallbackResult, err error) {
- fallbackRes = modelConfig.GetFallbackForModelError(numTotalRetry, didProviderFallback, modelErr, authVars, settings)
+ handleClaudeMaxRateLimitedIfNeeded(modelErr, modelConfig, authVars, settings, orgUserConfig, currentOrgId, currentUserId)
+
+ fallbackRes = modelConfig.GetFallbackForModelError(numTotalRetry, didProviderFallback, modelErr, authVars, settings, orgUserConfig)
resolvedModelConfig := fallbackRes.ModelRoleConfig
if resolvedModelConfig == nil {
return nil, fallbackRes, fmt.Errorf("model config is nil")
}
- providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings)
+ providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
opClient, ok := clients[providerComposite]
if !ok {
@@ -65,7 +70,7 @@ func CreateChatCompletionWithInternalStream(
}
modelConfig = resolvedModelConfig
- resp, err = processChatCompletionStream(resolvedModelConfig, opClient, authVars, settings, ctx, req, onStream, reqStarted)
+ resp, err = processChatCompletionStream(resolvedModelConfig, opClient, authVars, settings, orgUserConfig, ctx, req, onStream, reqStarted)
if err != nil {
return nil, fallbackRes, err
}
@@ -83,6 +88,7 @@ func processChatCompletionStream(
client ClientInfo,
authVars map[string]string,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
ctx context.Context,
req types.ExtendedChatCompletionRequest,
onStream OnStreamFn,
@@ -94,7 +100,7 @@ func processChatCompletionStream(
"model": modelConfig.ModelId,
}))
- stream, err := createChatCompletionStreamExtended(modelConfig, client, authVars, settings, streamCtx, req)
+ stream, err := createChatCompletionStreamExtended(modelConfig, client, authVars, settings, orgUserConfig, streamCtx, req)
if err != nil {
cancel()
diff --git a/app/server/model/model_error.go b/app/server/model/model_error.go
index 9c9aa4b4..a3e212f3 100644
--- a/app/server/model/model_error.go
+++ b/app/server/model/model_error.go
@@ -87,10 +87,27 @@ func ClassifyErrMsg(msg string) *shared.ModelError {
return nil
}
-func ClassifyModelError(code int, message string, headers http.Header) shared.ModelError {
+func ClassifyModelError(code int, message string, headers http.Header, isClaudeMax bool) shared.ModelError {
msg := strings.ToLower(message)
- // first try to classify the error based on the message only
+ // first of all, if it's claude max and a 429, it means the subscription limit was reached, so handle it accordingly
+ if isClaudeMax && code == 429 {
+ retryAfter := extractRetryAfter(headers, msg)
+ if retryAfter > 0 {
+ return shared.ModelError{
+ Kind: shared.ErrRateLimited,
+ Retriable: true,
+ RetryAfterSeconds: retryAfter,
+ }
+ }
+ return shared.ModelError{
+ Kind: shared.ErrRateLimited,
+ Retriable: false,
+ RetryAfterSeconds: 0,
+ }
+ }
+
+ // next try to classify the error based on the message only
msgRes := ClassifyErrMsg(msg)
if msgRes != nil {
log.Printf("Classified error message: %+v", msgRes)
@@ -210,13 +227,14 @@ func normalizeUnit(numStr, unit string) int {
}
}
-func classifyBasicError(err error) shared.ModelError {
+func classifyBasicError(err error, isClaudeMax bool) shared.ModelError {
// if it's an http error, classify it based on the status code and body
if httpErr, ok := err.(*HTTPError); ok {
me := ClassifyModelError(
httpErr.StatusCode,
httpErr.Body,
httpErr.Header,
+ isClaudeMax,
)
return me
}
diff --git a/app/server/model/model_request.go b/app/server/model/model_request.go
index 7ee4f741..c7b398d9 100644
--- a/app/server/model/model_request.go
+++ b/app/server/model/model_request.go
@@ -18,13 +18,14 @@ import (
)
type ModelRequestParams struct {
- Clients map[string]ClientInfo
- AuthVars map[string]string
- Auth *types.ServerAuth
- Plan *db.Plan
- ModelConfig *shared.ModelRoleConfig
- Settings *shared.PlanSettings
- Purpose string
+ Clients map[string]ClientInfo
+ AuthVars map[string]string
+ Auth *types.ServerAuth
+ Plan *db.Plan
+ ModelConfig *shared.ModelRoleConfig
+ Settings *shared.PlanSettings
+ OrgUserConfig *shared.OrgUserConfig
+ Purpose string
Messages []types.ExtendedChatMessage
Prediction string
@@ -69,12 +70,15 @@ func ModelRequest(
purpose := params.Purpose
sessionId := params.SessionId
settings := params.Settings
+ orgUserConfig := params.OrgUserConfig
+ currentOrgId := auth.OrgId
+ currentUserId := auth.User.Id
if purpose == "" {
return nil, fmt.Errorf("purpose is required")
}
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
messages = FilterEmptyMessages(messages)
messages = CheckSingleSystemMessage(modelConfig, baseModelConfig, messages)
@@ -166,7 +170,7 @@ func ModelRequest(
}
}
- res, err := CreateChatCompletionWithInternalStream(clients, authVars, modelConfig, settings, ctx, req, onStream, reqStarted)
+ res, err := CreateChatCompletionWithInternalStream(clients, authVars, modelConfig, settings, orgUserConfig, currentOrgId, currentUserId, ctx, req, onStream, reqStarted)
if err != nil {
return nil, err
diff --git a/app/server/model/name.go b/app/server/model/name.go
index 4cfb9362..c763a336 100644
--- a/app/server/model/name.go
+++ b/app/server/model/name.go
@@ -18,6 +18,7 @@ func GenPlanName(
auth *types.ServerAuth,
plan *db.Plan,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
clients map[string]ClientInfo,
authVars map[string]string,
planContent string,
@@ -29,7 +30,7 @@ func GenPlanName(
var tools []openai.Tool
var toolChoice *openai.ToolChoice
- baseModelConfig := config.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
var sysPrompt string
if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
@@ -66,17 +67,18 @@ func GenPlanName(
}
modelRes, err := ModelRequest(ctx, ModelRequestParams{
- Clients: clients,
- AuthVars: authVars,
- Auth: auth,
- Plan: plan,
- ModelConfig: &config,
- Purpose: "Plan name",
- Messages: messages,
- Tools: tools,
- ToolChoice: toolChoice,
- SessionId: sessionId,
- Settings: settings,
+ Clients: clients,
+ AuthVars: authVars,
+ Auth: auth,
+ Plan: plan,
+ ModelConfig: &config,
+ OrgUserConfig: orgUserConfig,
+ Purpose: "Plan name",
+ Messages: messages,
+ Tools: tools,
+ ToolChoice: toolChoice,
+ SessionId: sessionId,
+ Settings: settings,
})
if err != nil {
@@ -111,14 +113,15 @@ func GenPlanName(
}
type GenPipedDataNameParams struct {
- Ctx context.Context
- Auth *types.ServerAuth
- Plan *db.Plan
- Settings *shared.PlanSettings
- AuthVars map[string]string
- SessionId string
- Clients map[string]ClientInfo
- PipedContent string
+ Ctx context.Context
+ Auth *types.ServerAuth
+ Plan *db.Plan
+ Settings *shared.PlanSettings
+ OrgUserConfig *shared.OrgUserConfig
+ AuthVars map[string]string
+ SessionId string
+ Clients map[string]ClientInfo
+ PipedContent string
}
func GenPipedDataName(
@@ -132,6 +135,7 @@ func GenPipedDataName(
authVars := params.AuthVars
pipedContent := params.PipedContent
sessionId := params.SessionId
+ orgUserConfig := params.OrgUserConfig
config := settings.GetModelPack().Namer
@@ -139,7 +143,7 @@ func GenPipedDataName(
var tools []openai.Tool
var toolChoice *openai.ToolChoice
- baseModelConfig := config.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
sysPrompt = prompts.SysPipedDataNameXml
@@ -175,17 +179,18 @@ func GenPipedDataName(
}
modelRes, err := ModelRequest(ctx, ModelRequestParams{
- Clients: clients,
- Auth: auth,
- AuthVars: authVars,
- Plan: plan,
- ModelConfig: &config,
- Purpose: "Piped data name",
- Messages: messages,
- Tools: tools,
- ToolChoice: toolChoice,
- SessionId: sessionId,
- Settings: settings,
+ Clients: clients,
+ Auth: auth,
+ AuthVars: authVars,
+ Plan: plan,
+ ModelConfig: &config,
+ Purpose: "Piped data name",
+ Messages: messages,
+ Tools: tools,
+ ToolChoice: toolChoice,
+ SessionId: sessionId,
+ Settings: settings,
+ OrgUserConfig: orgUserConfig,
})
if err != nil {
@@ -224,6 +229,7 @@ func GenNoteName(
auth *types.ServerAuth,
plan *db.Plan,
settings *shared.PlanSettings,
+ orgUserConfig *shared.OrgUserConfig,
clients map[string]ClientInfo,
authVars map[string]string,
note string,
@@ -235,7 +241,7 @@ func GenNoteName(
var tools []openai.Tool
var toolChoice *openai.ToolChoice
- baseModelConfig := config.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
sysPrompt = prompts.SysNoteNameXml
@@ -271,17 +277,18 @@ func GenNoteName(
}
modelRes, err := ModelRequest(ctx, ModelRequestParams{
- Clients: clients,
- Auth: auth,
- AuthVars: authVars,
- Plan: plan,
- ModelConfig: &config,
- Purpose: "Note name",
- Messages: messages,
- Tools: tools,
- ToolChoice: toolChoice,
- SessionId: sessionId,
- Settings: settings,
+ Clients: clients,
+ Auth: auth,
+ AuthVars: authVars,
+ Plan: plan,
+ ModelConfig: &config,
+ Purpose: "Note name",
+ Messages: messages,
+ Tools: tools,
+ ToolChoice: toolChoice,
+ SessionId: sessionId,
+ Settings: settings,
+ OrgUserConfig: orgUserConfig,
})
if err != nil {
diff --git a/app/server/model/plan/build_exec.go b/app/server/model/plan/build_exec.go
index 49c95d7f..8342a6d1 100644
--- a/app/server/model/plan/build_exec.go
+++ b/app/server/model/plan/build_exec.go
@@ -17,12 +17,14 @@ import (
)
type BuildParams struct {
- Clients map[string]model.ClientInfo
- AuthVars map[string]string
- Plan *db.Plan
- Branch string
- Auth *types.ServerAuth
- SessionId string
+ Clients map[string]model.ClientInfo
+ AuthVars map[string]string
+ Plan *db.Plan
+ Branch string
+ Auth *types.ServerAuth
+ SessionId string
+ OrgUserConfig *shared.OrgUserConfig
+ Settings *shared.PlanSettings
}
func Build(params BuildParams) (int, error) {
@@ -32,6 +34,8 @@ func Build(params BuildParams) (int, error) {
branch := params.Branch
auth := params.Auth
sessionId := params.SessionId
+ orgUserConfig := params.OrgUserConfig
+ settings := params.Settings
log.Printf("Build: Called with plan ID %s on branch %s\n", plan.Id, branch)
log.Println("Build: Starting Build operation")
@@ -42,8 +46,10 @@ func Build(params BuildParams) (int, error) {
auth: auth,
currentOrgId: auth.OrgId,
currentUserId: auth.User.Id,
+ orgUserConfig: orgUserConfig,
plan: plan,
branch: branch,
+ settings: settings,
}
streamDone := func() {
diff --git a/app/server/model/plan/build_load.go b/app/server/model/plan/build_load.go
index 2310f32f..d109605d 100644
--- a/app/server/model/plan/build_load.go
+++ b/app/server/model/plan/build_load.go
@@ -32,6 +32,7 @@ func (state *activeBuildStreamState) loadPendingBuilds(sessionId string) (map[st
var modelContext []*db.Context
var pendingBuildsByPath map[string][]*types.ActiveBuild
var settings *shared.PlanSettings
+ var orgUserConfig *shared.OrgUserConfig
err = db.ExecRepoOperation(db.ExecRepoOperationParams{
OrgId: auth.OrgId,
@@ -43,7 +44,7 @@ func (state *activeBuildStreamState) loadPendingBuilds(sessionId string) (map[st
CancelFn: active.CancelFn,
Reason: "load pending builds",
}, func(repo *db.GitRepo) error {
- errCh := make(chan error, 3)
+ errCh := make(chan error, 4)
go func() {
defer func() {
@@ -104,7 +105,28 @@ func (state *activeBuildStreamState) loadPendingBuilds(sessionId string) (map[st
errCh <- nil
}()
- for i := 0; i < 3; i++ {
+ go func() {
+
+ defer func() {
+ if r := recover(); r != nil {
+ log.Printf("panic in getOrgUserConfig: %v\n%s", r, debug.Stack())
+ errCh <- fmt.Errorf("error getting org user config: %v", r)
+ runtime.Goexit() // don't allow outer function to continue and double-send to channel
+ }
+ }()
+
+ res, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ errCh <- fmt.Errorf("error getting org user config: %v", err)
+ return
+ }
+
+ orgUserConfig = res
+ errCh <- nil
+ }()
+
+ for i := 0; i < 4; i++ {
err = <-errCh
if err != nil {
log.Printf("Error getting plan data: %v\n", err)
@@ -129,6 +151,7 @@ func (state *activeBuildStreamState) loadPendingBuilds(sessionId string) (map[st
state.modelContext = modelContext
state.settings = settings
+ state.orgUserConfig = orgUserConfig
return pendingBuildsByPath, nil
}
diff --git a/app/server/model/plan/build_state.go b/app/server/model/plan/build_state.go
index ffccbef8..35790f82 100644
--- a/app/server/model/plan/build_state.go
+++ b/app/server/model/plan/build_state.go
@@ -20,6 +20,7 @@ type activeBuildStreamState struct {
auth *types.ServerAuth
currentOrgId string
currentUserId string
+ orgUserConfig *shared.OrgUserConfig
plan *db.Plan
branch string
settings *shared.PlanSettings
diff --git a/app/server/model/plan/build_validate_and_fix.go b/app/server/model/plan/build_validate_and_fix.go
index c6cb038c..0bad9dfa 100644
--- a/app/server/model/plan/build_validate_and_fix.go
+++ b/app/server/model/plan/build_validate_and_fix.go
@@ -199,7 +199,7 @@ func (fileState *activeBuildStreamFileState) buildValidate(
syntaxErrors := params.syntaxErrors
reasons := params.reasons
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, fileState.settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, fileState.settings, fileState.orgUserConfig)
// Get diff for validation
log.Printf("Getting diffs between original and updated content")
@@ -293,6 +293,7 @@ func (fileState *activeBuildStreamFileState) buildValidate(
SessionId: params.sessionId,
EstimatedOutputTokens: maxExpectedOutputTokens,
Settings: fileState.settings,
+ OrgUserConfig: fileState.orgUserConfig,
})
if err != nil {
diff --git a/app/server/model/plan/build_whole_file.go b/app/server/model/plan/build_whole_file.go
index f09f400e..01ac45e8 100644
--- a/app/server/model/plan/build_whole_file.go
+++ b/app/server/model/plan/build_whole_file.go
@@ -35,7 +35,7 @@ func (fileState *activeBuildStreamFileState) buildWholeFileFallback(buildCtx con
return "", fmt.Errorf("active plan not found for plan ID %s and branch %s", planId, branch)
}
- baseModelConfig := config.GetBaseModelConfig(authVars, fileState.settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, fileState.settings, fileState.orgUserConfig)
originalFileWithLineNums := shared.AddLineNums(originalFile)
proposedContentWithLineNums := shared.AddLineNums(proposedContent)
@@ -109,8 +109,9 @@ func (fileState *activeBuildStreamFileState) buildWholeFileFallback(buildCtx con
WillCacheNumTokens: willCacheNumTokens,
EstimatedOutputTokens: maxExpectedOutputTokens,
- SessionId: sessionId,
- Settings: fileState.settings,
+ SessionId: sessionId,
+ Settings: fileState.settings,
+ OrgUserConfig: fileState.orgUserConfig,
})
if err != nil {
diff --git a/app/server/model/plan/commit_msg.go b/app/server/model/plan/commit_msg.go
index 2dac1aca..962f5b6b 100644
--- a/app/server/model/plan/commit_msg.go
+++ b/app/server/model/plan/commit_msg.go
@@ -26,6 +26,7 @@ func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescri
settings := state.settings
clients := state.clients
authVars := state.authVars
+ orgUserConfig := state.orgUserConfig
config := settings.GetModelPack().CommitMsg
activePlan := GetActivePlan(planId, branch)
@@ -39,7 +40,7 @@ func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescri
}
}
- baseModelConfig := config.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
var sysPrompt string
var tools []openai.Tool
@@ -97,6 +98,7 @@ func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescri
ConvoMessageId: state.replyId,
SessionId: activePlan.SessionId,
Settings: settings,
+ OrgUserConfig: orgUserConfig,
}
if tools != nil {
diff --git a/app/server/model/plan/exec_status.go b/app/server/model/plan/exec_status.go
index c384e64b..d4409065 100644
--- a/app/server/model/plan/exec_status.go
+++ b/app/server/model/plan/exec_status.go
@@ -34,8 +34,9 @@ func (state *activeTellStreamState) execStatusShouldContinue(currentMessage stri
clients := state.clients
authVars := state.authVars
config := settings.GetModelPack().ExecStatus
+ orgUserConfig := state.orgUserConfig
- baseModelConfig := config.GetBaseModelConfig(authVars, settings)
+ baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
currentSubtask := state.currentSubtask
if currentSubtask == nil {
@@ -156,6 +157,7 @@ func (state *activeTellStreamState) execStatusShouldContinue(currentMessage stri
ConvoMessageId: state.replyId,
SessionId: sessionId,
Settings: settings,
+ OrgUserConfig: orgUserConfig,
})
if err != nil {
diff --git a/app/server/model/plan/tell_build_pending.go b/app/server/model/plan/tell_build_pending.go
index dce0e7dd..cd2ae724 100644
--- a/app/server/model/plan/tell_build_pending.go
+++ b/app/server/model/plan/tell_build_pending.go
@@ -71,6 +71,7 @@ func (state *activeTellStreamState) queuePendingBuilds() {
branch: branch,
settings: state.settings,
modelContext: state.modelContext,
+ orgUserConfig: state.orgUserConfig,
}
for _, pendingBuilds := range pendingBuildsByPath {
diff --git a/app/server/model/plan/tell_exec.go b/app/server/model/plan/tell_exec.go
index 89f5fa69..99f41b43 100644
--- a/app/server/model/plan/tell_exec.go
+++ b/app/server/model/plan/tell_exec.go
@@ -410,7 +410,7 @@ func execTellPlan(params execTellPlanParams) {
state.modelConfig = &modelConfig
- baseModelConfig := modelConfig.GetBaseModelConfig(authVars, state.settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(authVars, state.settings, state.orgUserConfig)
if baseModelConfig == nil {
log.Println("Tell plan - baseModelConfig is nil")
@@ -497,11 +497,11 @@ func (state *activeTellStreamState) doTellRequest() {
modelConfig := state.modelConfig
active := state.activePlan
- fallbackRes := modelConfig.GetFallbackForModelError(state.numErrorRetry, state.didProviderFallback, state.modelErr, authVars, state.settings)
+ fallbackRes := modelConfig.GetFallbackForModelError(state.numErrorRetry, state.didProviderFallback, state.modelErr, authVars, state.settings, state.orgUserConfig)
modelConfig = fallbackRes.ModelRoleConfig
stop := []string{"<PlandexFinish/>"}
- baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)
if fallbackRes.FallbackType == shared.FallbackTypeProvider {
state.didProviderFallback = true
@@ -565,7 +565,7 @@ func (state *activeTellStreamState) doTellRequest() {
state.numErrorRetry, state.numFallbackRetry, baseModelConfig.ModelName)
// start the stream
- stream, err := model.CreateChatCompletionStream(clients, authVars, modelConfig, state.settings, active.ModelStreamCtx, modelReq)
+ stream, err := model.CreateChatCompletionStream(clients, authVars, modelConfig, state.settings, state.orgUserConfig, state.currentOrgId, state.currentUserId, active.ModelStreamCtx, modelReq)
if err != nil {
log.Printf("Error starting reply stream: %v\n", err)
go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error starting reply stream: %v", err))
diff --git a/app/server/model/plan/tell_load.go b/app/server/model/plan/tell_load.go
index 8449f588..4cc06512 100644
--- a/app/server/model/plan/tell_load.go
+++ b/app/server/model/plan/tell_load.go
@@ -47,6 +47,7 @@ func (state *activeTellStreamState) loadTellPlan() error {
var summaries []*db.ConvoSummary
var subtasks []*db.Subtask
var settings *shared.PlanSettings
+ var orgUserConfig *shared.OrgUserConfig
var latestSummaryTokens int
var currentPlan *shared.CurrentPlanState
@@ -82,11 +83,20 @@ func (state *activeTellStreamState) loadTellPlan() error {
}
settings = res
+ orgUserConfigRes, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
+ if err != nil {
+ log.Printf("Error getting org user config: %v\n", err)
+ errCh <- fmt.Errorf("error getting org user config: %v", err)
+ return
+ }
+ orgUserConfig = orgUserConfigRes
+
if plan.Name == "draft" {
name, err := model.GenPlanName(
auth,
plan,
settings,
+ orgUserConfig,
clients,
authVars,
req.Prompt,
diff --git a/app/server/model/plan/tell_state.go b/app/server/model/plan/tell_state.go
index 9c579aa6..8f773b50 100644
--- a/app/server/model/plan/tell_state.go
+++ b/app/server/model/plan/tell_state.go
@@ -20,6 +20,7 @@ type activeTellStreamState struct {
auth *types.ServerAuth
currentOrgId string
currentUserId string
+ orgUserConfig *shared.OrgUserConfig
plan *db.Plan
branch string
iteration int
diff --git a/app/server/model/plan/tell_stream_finish.go b/app/server/model/plan/tell_stream_finish.go
index 94de4870..5f382554 100644
--- a/app/server/model/plan/tell_stream_finish.go
+++ b/app/server/model/plan/tell_stream_finish.go
@@ -31,6 +31,7 @@ func (state *activeTellStreamState) handleStreamFinished() handleStreamFinishedR
clients := state.clients
authVars := state.authVars
settings := state.settings
+ orgUserConfig := state.orgUserConfig
currentOrgId := state.currentOrgId
summaries := state.summaries
convo := state.convo
@@ -126,7 +127,7 @@ func (state *activeTellStreamState) handleStreamFinished() handleStreamFinishedR
}
}()
- err := summarizeConvo(clients, authVars, settings, summarizeConvoParams{
+ err := summarizeConvo(clients, authVars, settings, orgUserConfig, summarizeConvoParams{
auth: auth,
plan: plan,
branch: branch,
diff --git a/app/server/model/plan/tell_stream_main.go b/app/server/model/plan/tell_stream_main.go
index e9f0ba32..f6f79473 100644
--- a/app/server/model/plan/tell_stream_main.go
+++ b/app/server/model/plan/tell_stream_main.go
@@ -63,7 +63,7 @@ func (state *activeTellStreamState) listenStream(stream *model.ExtendedChatCompl
defer timer.Stop()
streamFinished := false
- baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings)
+ baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)
modelProvider := baseModelConfig.Provider
modelName := baseModelConfig.ModelName
diff --git a/app/server/model/plan/tell_stream_processor.go b/app/server/model/plan/tell_stream_processor.go
index ca3cf591..1b3dfde8 100644
--- a/app/server/model/plan/tell_stream_processor.go
+++ b/app/server/model/plan/tell_stream_processor.go
@@ -58,7 +58,7 @@ func (state *activeTellStreamState) processChunk(choice types.ExtendedChatComple
delta := choice.Delta
content := delta.Content
- baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings)
+ baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)
if baseModelConfig.IncludeReasoning && !baseModelConfig.HideReasoning && delta.Reasoning != "" {
content = delta.Reasoning
@@ -560,6 +560,7 @@ func (state *activeTellStreamState) handleNewOperations(parserRes *types.ReplyPa
branch: branch,
settings: settings,
modelContext: state.modelContext,
+ orgUserConfig: state.orgUserConfig,
}
var opContentTokens int
diff --git a/app/server/model/plan/tell_stream_usage.go b/app/server/model/plan/tell_stream_usage.go
index ea72feaf..02a0c52b 100644
--- a/app/server/model/plan/tell_stream_usage.go
+++ b/app/server/model/plan/tell_stream_usage.go
@@ -27,7 +27,7 @@ func (state *activeTellStreamState) handleUsageChunk(usage *openai.Usage) {
sessionId := state.activePlan.SessionId
modelConfig := state.modelConfig
- baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)
go func() {
defer func() {
@@ -90,7 +90,7 @@ func (state *activeTellStreamState) execHookOnStop(sendStreamErr bool) {
}
modelConfig := state.modelConfig
- baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings)
+ baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)
go func() {
defer func() {
diff --git a/app/server/model/plan/tell_summary.go b/app/server/model/plan/tell_summary.go
index 6855c077..01112c69 100644
--- a/app/server/model/plan/tell_summary.go
+++ b/app/server/model/plan/tell_summary.go
@@ -243,7 +243,7 @@ type summarizeConvoParams struct {
modelPackName string
}
-func summarizeConvo(clients map[string]model.ClientInfo, authVars map[string]string, settings *shared.PlanSettings, params summarizeConvoParams, ctx context.Context) *shared.ApiError {
+func summarizeConvo(clients map[string]model.ClientInfo, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, params summarizeConvoParams, ctx context.Context) *shared.ApiError {
plan := params.plan
planId := plan.Id
log.Printf("summarizeConvo: Called for plan ID %s on branch %s\n", planId, params.branch)
@@ -394,7 +394,7 @@ func summarizeConvo(clients map[string]model.ClientInfo, authVars map[string]str
// latestSummaryCh := make(chan *db.ConvoSummary, 1)
// active.LatestSummaryCh = latestSummaryCh
- summary, apiErr := model.PlanSummary(clients, authVars, settings, config, model.PlanSummaryParams{
+ summary, apiErr := model.PlanSummary(clients, authVars, settings, orgUserConfig, config, model.PlanSummaryParams{
Conversation: summaryMessages,
ConversationNumTokens: numTokens,
LatestConvoMessageId: latestMessageId,
diff --git a/app/server/model/summarize.go b/app/server/model/summarize.go
index 1e8262d5..fb71b243 100644
--- a/app/server/model/summarize.go
+++ b/app/server/model/summarize.go
@@ -28,7 +28,7 @@ type PlanSummaryParams struct {
SessionId string
}
-func PlanSummary(clients map[string]ClientInfo, authVars map[string]string, settings *shared.PlanSettings, config shared.ModelRoleConfig, params PlanSummaryParams, ctx context.Context) (*db.ConvoSummary, *shared.ApiError) {
+func PlanSummary(clients map[string]ClientInfo, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, config shared.ModelRoleConfig, params PlanSummaryParams, ctx context.Context) (*db.ConvoSummary, *shared.ApiError) {
messages := []types.ExtendedChatMessage{
{
Role: openai.ChatMessageRoleSystem,
@@ -67,6 +67,7 @@ func PlanSummary(clients map[string]ClientInfo, authVars map[string]string, sett
Messages: messages,
SessionId: params.SessionId,
Settings: settings,
+ OrgUserConfig: orgUserConfig,
})
if err != nil {
diff --git a/app/server/routes/routes.go b/app/server/routes/routes.go
index a4f36d61..a639d101 100644
--- a/app/server/routes/routes.go
+++ b/app/server/routes/routes.go
@@ -184,6 +184,9 @@ func addApiRoutes(r *mux.Router, prefix string) {
HandlePlandexFn(r, prefix+"/default_plan_config", false, handlers.GetDefaultPlanConfigHandler).Methods("GET")
HandlePlandexFn(r, prefix+"/default_plan_config", false, handlers.UpdateDefaultPlanConfigHandler).Methods("PUT")
+
+ HandlePlandexFn(r, prefix+"/org_user_config", false, handlers.GetOrgUserConfigHandler).Methods("GET")
+ HandlePlandexFn(r, prefix+"/org_user_config", false, handlers.UpdateOrgUserConfigHandler).Methods("PUT")
}
func addProxyableApiRoutes(r *mux.Router, prefix string) {
diff --git a/app/server/types/message.go b/app/server/types/message.go
index d2037075..6313a9b6 100644
--- a/app/server/types/message.go
+++ b/app/server/types/message.go
@@ -131,11 +131,16 @@ type ExtendedChatCompletionRequest struct {
Provider *OpenRouterProviderConfig `json:"provider,omitempty"`
// LiteLLM api base
- LiteLLMApiBase string `json:"api_base,omitempty"`
+ LiteLLMApiBase string `json:"api_base,omitempty"`
+ LiteLLMBaseUrl string `json:"base_url,omitempty"`
+ LiteLLMCustomLLMProvider string `json:"custom_llm_provider,omitempty"`
// Openrouter/LiteLLM reasoning
ReasoningConfig *ReasoningConfig `json:"reasoning,omitempty"`
+ // Headers that pass through to LiteLLM proxy
+ ExtraHeaders map[string]string `json:"extra_headers,omitempty"`
+
// Vertex request vars
VertexProject string `json:"vertex_project,omitempty"`
VertexLocation string `json:"vertex_location,omitempty"`
diff --git a/app/shared/ai_models_available.go b/app/shared/ai_models_available.go
index 252120d8..82f3e60e 100644
--- a/app/shared/ai_models_available.go
+++ b/app/shared/ai_models_available.go
@@ -596,6 +596,24 @@ var AvailableModelsByComposite = map[string]*AvailableModel{}
func init() {
for _, model := range BuiltInModels {
+ // if the model has an anthropic provider, insert claude max provider before it
+ var usesAnthropicProvider *BaseModelUsesProvider
+ for _, provider := range model.Providers {
+ if provider.Provider == ModelProviderAnthropic {
+ copy := provider
+ latestModelName, ok := AnthropicLatestModelNameMap[provider.ModelName]
+ if ok {
+ copy.ModelName = latestModelName
+ }
+ usesAnthropicProvider = &copy
+ break
+ }
+ }
+ if usesAnthropicProvider != nil {
+ usesAnthropicProvider.Provider = ModelProviderAnthropicClaudeMax
+ model.Providers = append([]BaseModelUsesProvider{*usesAnthropicProvider}, model.Providers...)
+ }
+
AvailableModels = append(AvailableModels, model.ToAvailableModels()...)
var addVariants func(variants []BaseModelConfigVariant, baseId ModelId)
@@ -678,7 +696,7 @@ func init() {
panic("reserved output tokens is not set")
}
- if model.ApiKeyEnvVar == "" && len(model.ExtraAuthVars) == 0 && !model.SkipAuth && !model.HasAWSAuth {
+ if model.ApiKeyEnvVar == "" && len(model.ExtraAuthVars) == 0 && !model.SkipAuth && !model.HasAWSAuth && !model.HasClaudeMaxAuth {
spew.Dump(model)
panic("api key or auth settings are not set")
}
@@ -702,3 +720,11 @@ func GetAvailableModel(provider ModelProvider, modelId ModelId) *AvailableModel
compositeKey := string(provider) + "/" + string(modelId)
return AvailableModelsByComposite[compositeKey]
}
+
+var AnthropicLatestModelNameMap = map[ModelName]ModelName{
+ "anthropic/claude-sonnet-4-0": "anthropic/claude-sonnet-4-20250514",
+ "anthropic/claude-opus-4-0": "anthropic/claude-opus-4-20250514",
+ "anthropic/claude-3-7-sonnet-latest": "anthropic/claude-3-7-sonnet-20250219",
+ "anthropic/claude-3-5-haiku-latest": "anthropic/claude-3-5-haiku-20241022",
+ "anthropic/claude-3-5-sonnet-latest": "anthropic/claude-3-5-sonnet-20241022",
+}
diff --git a/app/shared/ai_models_custom.go b/app/shared/ai_models_custom.go
index b6c5a362..2977367a 100644
--- a/app/shared/ai_models_custom.go
+++ b/app/shared/ai_models_custom.go
@@ -272,8 +272,8 @@ func (cp *CustomProvider) ToModelProviderConfigSchema() ModelProviderConfigSchem
}
}
-func (input *CustomModel) ToBaseModelConfig(authVars map[string]string, settings *PlanSettings) *BaseModelConfig {
- providers := GetProvidersForAuthVarsWithModelId(authVars, settings, input.ModelId)
+func (input *CustomModel) ToBaseModelConfig(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *BaseModelConfig {
+ providers := GetProvidersForAuthVarsWithModelId(authVars, settings, input.ModelId, orgUserConfig)
if len(providers) == 0 {
return nil
diff --git a/app/shared/ai_models_data_models.go b/app/shared/ai_models_data_models.go
index 2fd813a7..d3fb69ef 100644
--- a/app/shared/ai_models_data_models.go
+++ b/app/shared/ai_models_data_models.go
@@ -583,8 +583,8 @@ func (m ModelRoleConfig) GetModelId() ModelId {
return m.ModelId
}
-func (m ModelRoleConfig) GetBaseModelConfig(authVars map[string]string, settings *PlanSettings) *BaseModelConfig {
- foundProvider := m.GetFirstProviderForAuthVars(authVars, settings)
+func (m ModelRoleConfig) GetBaseModelConfig(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *BaseModelConfig {
+ foundProvider := m.GetFirstProviderForAuthVars(authVars, settings, orgUserConfig)
if foundProvider == nil {
return nil
}
@@ -615,8 +615,8 @@ func (m ModelRoleConfig) GetBaseModelConfigForProvider(authVars map[string]strin
return nil
}
-func (m ModelRoleConfig) GetProviderComposite(authVars map[string]string, settings *PlanSettings) string {
- baseModelConfig := m.GetBaseModelConfig(authVars, settings)
+func (m ModelRoleConfig) GetProviderComposite(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) string {
+ baseModelConfig := m.GetBaseModelConfig(authVars, settings, orgUserConfig)
if baseModelConfig == nil {
return ""
diff --git a/app/shared/ai_models_errors.go b/app/shared/ai_models_errors.go
index c3be5ad1..5d67d6ac 100644
--- a/app/shared/ai_models_errors.go
+++ b/app/shared/ai_models_errors.go
@@ -47,6 +47,7 @@ func (m *ModelRoleConfig) GetFallbackForModelError(
modelErr *ModelError,
authVars map[string]string,
settings *PlanSettings,
+ orgUserConfig *OrgUserConfig,
) FallbackResult {
if m == nil || modelErr == nil {
return FallbackResult{
@@ -72,7 +73,7 @@ func (m *ModelRoleConfig) GetFallbackForModelError(
} else if !didProviderFallback {
log.Println("no error fallback, trying provider fallback")
- providerFallback := m.GetProviderFallback(authVars, settings)
+ providerFallback := m.GetProviderFallback(authVars, settings, orgUserConfig)
log.Println(spew.Sdump(map[string]interface{}{
"providerFallback": providerFallback,
@@ -97,21 +98,27 @@ func (m *ModelRoleConfig) GetFallbackForModelError(
// we just try a single provider fallback if all defined fallbacks are exhausted
// if we've got openrouter credentials in the stack, we always use OpenRouter as the fallback since it has its own routing/fallback routing to maximize resilience
// otherwise we just use the second provider in the stack
-func (m ModelRoleConfig) GetProviderFallback(authVars map[string]string, settings *PlanSettings) *ModelRoleConfig {
- providers := m.GetProvidersForAuthVars(authVars, settings)
+// if we're using the claude subscription, we also go to second provider in the stack rather than openrouter
+func (m ModelRoleConfig) GetProviderFallback(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *ModelRoleConfig {
+ providers := m.GetProvidersForAuthVars(authVars, settings, orgUserConfig)
if len(providers) < 2 {
return nil
}
+ firstProvider := providers[0]
+
res := ModelRoleConfig{}
copier.Copy(&res, m)
var provider ModelProvider
- for _, p := range providers {
- if p.Provider == ModelProviderOpenRouter {
- provider = p.Provider
- break
+
+ if !firstProvider.HasClaudeMaxAuth {
+ for _, p := range providers {
+ if p.Provider == ModelProviderOpenRouter {
+ provider = p.Provider
+ break
+ }
}
}
@@ -125,7 +132,7 @@ func (m ModelRoleConfig) GetProviderFallback(authVars map[string]string, setting
c := availableModel.BaseModelConfig
res.BaseModelConfig = &c
} else {
- c := m.GetBaseModelConfig(authVars, settings)
+ c := m.GetBaseModelConfig(authVars, settings, orgUserConfig)
res.BaseModelConfig = c
}
diff --git a/app/shared/ai_models_providers.go b/app/shared/ai_models_providers.go
index 392c1ed3..6e543abb 100644
--- a/app/shared/ai_models_providers.go
+++ b/app/shared/ai_models_providers.go
@@ -16,6 +16,11 @@ const AzureOpenAIEnvVar = "AZURE_OPENAI_API_KEY"
const DeepSeekApiKeyEnvVar = "DEEPSEEK_API_KEY"
const PerplexityApiKeyEnvVar = "PERPLEXITY_API_KEY"
+// not set directly via env vars, but used for auth var resolution
+const AnthropicClaudeMaxTokenEnvVar = "ANTHROPIC_CLAUDE_MAX_TOKEN"
+const AnthropicClaudeMaxBetaHeader = "oauth-2025-04-20"
+const LiteLLMAnthropicBaseUrl = "https://api.anthropic.com"
+
type ModelPublisher string
const (
@@ -34,12 +39,13 @@ const (
ModelProviderOpenRouter ModelProvider = "openrouter"
ModelProviderOpenAI ModelProvider = "openai"
- ModelProviderAnthropic ModelProvider = "anthropic"
- ModelProviderGoogleAIStudio ModelProvider = "google-ai-studio"
- ModelProviderGoogleVertex ModelProvider = "google-vertex"
- ModelProviderAzureOpenAI ModelProvider = "azure-openai"
- ModelProviderDeepSeek ModelProvider = "deepseek"
- ModelProviderPerplexity ModelProvider = "perplexity"
+ ModelProviderAnthropic ModelProvider = "anthropic"
+ ModelProviderAnthropicClaudeMax ModelProvider = "anthropic-claude-max"
+ ModelProviderGoogleAIStudio ModelProvider = "google-ai-studio"
+ ModelProviderGoogleVertex ModelProvider = "google-vertex"
+ ModelProviderAzureOpenAI ModelProvider = "azure-openai"
+ ModelProviderDeepSeek ModelProvider = "deepseek"
+ ModelProviderPerplexity ModelProvider = "perplexity"
ModelProviderAmazonBedrock ModelProvider = "aws-bedrock"
@@ -59,6 +65,7 @@ var AllModelProviders = []ModelProvider{
ModelProviderOpenRouter,
ModelProviderOpenAI,
ModelProviderAnthropic,
+ ModelProviderAnthropicClaudeMax,
ModelProviderGoogleAIStudio,
ModelProviderGoogleVertex,
ModelProviderAzureOpenAI,
@@ -84,6 +91,9 @@ type ModelProviderConfigSchema struct {
// for AWS Bedrock models
HasAWSAuth bool `json:"hasAWSAuth,omitempty"`
+ // for Claude Max integration
+ HasClaudeMaxAuth bool `json:"hasClaudeMaxAuth,omitempty"`
+
// for local models that don't require auth (ollama, etc.)
SkipAuth bool `json:"skipAuth,omitempty"`
LocalOnly bool `json:"localOnly,omitempty"`
@@ -125,6 +135,11 @@ var BuiltInModelProviderConfigs = map[ModelProvider]ModelProviderConfigSchema{
BaseUrl: LiteLLMBaseUrl,
ApiKeyEnvVar: AnthropicApiKeyEnvVar,
},
+ ModelProviderAnthropicClaudeMax: {
+ Provider: ModelProviderAnthropicClaudeMax,
+ BaseUrl: LiteLLMBaseUrl,
+ HasClaudeMaxAuth: true,
+ },
ModelProviderGoogleAIStudio: {
Provider: ModelProviderGoogleAIStudio,
BaseUrl: LiteLLMBaseUrl,
@@ -211,7 +226,12 @@ func init() {
}
}
-func GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings) []ModelProviderConfigSchema {
+func GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
+ var claudeSubscriptionCooldownActive bool
+ if orgUserConfig != nil {
+ claudeSubscriptionCooldownActive = orgUserConfig.IsClaudeSubscriptionCooldownActive()
+ }
+
var foundProviders []ModelProviderConfigSchema
allProviders := []ModelProviderConfigSchema{}
@@ -227,6 +247,10 @@ func GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings)
}
for _, providerConfig := range allProviders {
+ // filter out claude max if the cooldown is active
+ if claudeSubscriptionCooldownActive && providerConfig.HasClaudeMaxAuth {
+ continue
+ }
if providerConfig.SkipAuth {
foundProviders = append(foundProviders, providerConfig)
@@ -260,7 +284,7 @@ func GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings)
return foundProviders
}
-func GetProvidersForAuthVarsWithModelId(authVars map[string]string, settings *PlanSettings, modelId ModelId) []ModelProviderConfigSchema {
+func GetProvidersForAuthVarsWithModelId(authVars map[string]string, settings *PlanSettings, modelId ModelId, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
var localProvider ModelProvider
if settings != nil {
modelPack := settings.GetModelPack()
@@ -281,7 +305,7 @@ func GetProvidersForAuthVarsWithModelId(authVars map[string]string, settings *Pl
return []ModelProviderConfigSchema{}
}
- providers := GetProvidersForAuthVars(authVars, settings)
+ providers := GetProvidersForAuthVars(authVars, settings, orgUserConfig)
providersByComposite := map[string]ModelProviderConfigSchema{}
for _, provider := range providers {
providersByComposite[provider.ToComposite()] = provider
@@ -307,12 +331,12 @@ func GetProvidersForAuthVarsWithModelId(authVars map[string]string, settings *Pl
}
-func (m ModelRoleConfig) GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings) []ModelProviderConfigSchema {
- return GetProvidersForAuthVarsWithModelId(authVars, settings, m.ModelId)
+func (m ModelRoleConfig) GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
+ return GetProvidersForAuthVarsWithModelId(authVars, settings, m.ModelId, orgUserConfig)
}
-func (m ModelRoleConfig) GetFirstProviderForAuthVars(authVars map[string]string, settings *PlanSettings) *ModelProviderConfigSchema {
- providers := m.GetProvidersForAuthVars(authVars, settings)
+func (m ModelRoleConfig) GetFirstProviderForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *ModelProviderConfigSchema {
+ providers := m.GetProvidersForAuthVars(authVars, settings, orgUserConfig)
if len(providers) == 0 {
return nil
}
diff --git a/app/shared/data_models.go b/app/shared/data_models.go
index 3d6bfe1d..18ee8451 100644
--- a/app/shared/data_models.go
+++ b/app/shared/data_models.go
@@ -32,6 +32,8 @@ type OrgUser struct {
OrgId string `json:"orgId"`
UserId string `json:"userId"`
OrgRoleId string `json:"orgRoleId"`
+
+ Config *OrgUserConfig `json:"config,omitempty"`
}
type Invite struct {
diff --git a/app/shared/org_user_config.go b/app/shared/org_user_config.go
new file mode 100644
index 00000000..30c23a54
--- /dev/null
+++ b/app/shared/org_user_config.go
@@ -0,0 +1,53 @@
+package shared
+
+import (
+ "database/sql/driver"
+ "encoding/json"
+ "fmt"
+ "time"
+)
+
+const claudeSubscriptionCooldownDuration = 1 * time.Hour
+
+type OrgUserConfig struct {
+ PromptedClaudeMax bool `json:"promptedClaudeMax"`
+ UseClaudeSubscription bool `json:"useClaudeSubscription"`
+ ClaudeSubscriptionCooldownStartedAt time.Time `json:"claudeSubscriptionCooldownStartedAt"`
+}
+
+func (p *OrgUserConfig) IsClaudeSubscriptionCooldownActive() bool {
+ if p == nil || p.ClaudeSubscriptionCooldownStartedAt.IsZero() {
+ return false // never started
+ }
+ return time.Since(p.ClaudeSubscriptionCooldownStartedAt) < claudeSubscriptionCooldownDuration
+}
+
+func (p *OrgUserConfig) Scan(src interface{}) error {
+ if src == nil {
+ *p = OrgUserConfig{}
+ return nil
+ }
+ switch s := src.(type) {
+ case []byte:
+ if len(s) == 0 {
+ *p = OrgUserConfig{}
+ return nil
+ }
+ return json.Unmarshal(s, p)
+ case string:
+ if s == "" {
+ *p = OrgUserConfig{}
+ return nil
+ }
+ return json.Unmarshal([]byte(s), p)
+ default:
+ return fmt.Errorf("unsupported data type: %T", src)
+ }
+}
+
+func (p *OrgUserConfig) Value() (driver.Value, error) {
+ if p == nil {
+ return nil, nil
+ }
+ return json.Marshal(p)
+}
diff --git a/app/shared/plan_config.go b/app/shared/plan_config.go
index eb7aea25..5640fcd5 100644
--- a/app/shared/plan_config.go
+++ b/app/shared/plan_config.go
@@ -93,6 +93,7 @@ type PlanConfig struct {
// PlainTextMode bool `json:"plainTextMode"`
// PlainTextCommands bool `json:"plainTextCommands"`
// PlainTextStream bool `json:"plainTextStream"`
+
}
var DefaultPlanConfig = PlanConfig{}