[docs] Add official docs for go (#2253)

<!-- ELLIPSIS_HIDDEN -->


> [!IMPORTANT]
> Adds official documentation and support for Go language in BAML,
including setup, usage examples, and type mappings.
> 
>   - **Documentation**:
> - Adds `go.mdx` to `fern/01-guide/02-languages/` for Go language setup
and usage.
> - Updates `docker.mdx`, `terminal-logs.mdx`,
`upgrade-baml-versions.mdx`, `concurrent-calls.mdx`,
`error-handling.mdx`, `multi-modal.mdx`, `my-first-function.mdx`,
`streaming.mdx`, `checks-and-asserts.mdx`, `client-registry.mdx`,
`collector.mdx`, `dynamic-types.mdx`, `modular-api.mdx`,
`chat-history.mdx`, `tools.mdx`, `studio.mdx`,
`what-are-function-definitions.mdx`, `what-is-baml_client.mdx`,
`init.mdx`, `types.mdx`, `audio.mdx`, `client.mdx`, `image.mdx`,
`pdf.mdx`, `typebuilder.mdx`, `with_options.mdx`, `generator.mdx` to
include Go examples and instructions.
>     - Adds Go type mappings to `supported-types.mdx`.
>   - **Configuration**:
>     - Updates `docs.yml` to include Go in navigation.
> - Updates `package.json` and `turbo.json` for Go support in
development scripts.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for 8daebf8. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>


<!-- ELLIPSIS_HIDDEN -->

Author: hellovai

fern/01-guide/02-languages/go.mdx

@@ -0,0 +1,177 @@
+---
+title: Go
+---
+
+To set up BAML with Go do the following:
+
+<Steps>
+  ### Install BAML VSCode/Cursor Extension
+      https://marketplace.visualstudio.com/items?itemName=boundary.baml-extension
+
+      - syntax highlighting
+      - testing playground
+      - prompt previews
+
+  ### Install BAML CLI and Initialize Project
+      ```bash go
+      go install github.com/boundaryml/baml/go/baml-cli@latest && baml-cli init
+      ```
+
+      This command will:
+      1. Install the BAML CLI tool globally
+      2. Create starter BAML code in a `baml_src` directory
+      3. Set up the basic project structure
+
+  ### Install BAML Go Runtime
+      After initializing your project, install the Go runtime library:
+
+      ```bash go
+      go get github.com/boundaryml/baml
+      ```
+
+  ### Install Required Go Tools
+      The BAML generator uses `gofmt` and `goimports` to format the generated Go code. Install these tools:
+
+      ```bash go
+      # gofmt comes with Go by default, but install goimports
+      go install golang.org/x/tools/cmd/goimports@latest
+      ```
+
+      These tools are required by the `on_generate` command in your generator configuration and ensure the generated code is properly formatted.
+
+  ### Generate the `baml_client` Go package from `.baml` files
+
+    One of the files in your `baml_src` directory will have a [generator block](/ref/baml/generator). This tells BAML how to generate the `baml_client` directory, which will have auto-generated Go code to call your BAML functions.
+
+    Any types defined in .baml files will be converted into Go structs in the `baml_client` directory.
+
+    ```bash
+    baml-cli generate
+    ```
+
+    You can modify your build process to always call baml-cli generate before building.
+
+    ```makefile Makefile
+    .PHONY: generate build
+
+    generate:
+    	baml-cli generate
+
+    build: generate
+    	go build ./...
+
+    test: generate
+    	go test ./...
+    ```
+
+    See [What is baml_client](/guide/introduction/baml_client) to learn more about how this works.
+
+    <Tip>
+      If you set up the [VSCode extension](https://marketplace.visualstudio.com/items?itemName=Boundary.baml-extension), it will automatically run `baml-cli generate` on saving a BAML file.
+    </Tip>
+
+  ### Use a BAML function in Go!
+    <Error>If `baml_client` doesn't exist, make sure to run the previous step! </Error>
+
+    ```go main.go
+    package main
+
+    import (
+        "context"
+        "fmt"
+        "log"
+
+        b "example.com/myproject/baml_client"
+        "example.com/myproject/baml_client/types"
+    )
+
+    func main() {
+        ctx := context.Background()
+
+        // BAML's internal parser guarantees ExtractResume
+        // to always return a Resume type or an error
+        resume, err := b.ExtractResume(ctx, rawResume)
+        if err != nil {
+            log.Fatal(err)
+        }
+
+        fmt.Printf("Extracted resume: %+v\n", resume)
+    }
+
+    func exampleStream(rawResume string) (*types.Resume, error) {
+        ctx := context.Background()
+        
+        stream, err := b.Stream.ExtractResume(ctx, rawResume)
+        if err != nil {
+            return nil, err
+        }
+
+        for value := range stream {
+            if value.IsError {
+                return nil, value.Error
+            }
+            
+            if !value.IsFinal && value.Stream() != nil {
+                partial := *value.Stream()
+                fmt.Printf("Partial: %+v\n", partial) // This will be a partial Resume type
+            }
+            
+            if value.IsFinal && value.Final() != nil {
+                final := *value.Final()
+                return &final, nil // This will be a complete Resume type
+            }
+        }
+        
+        return nil, fmt.Errorf("stream ended without final response")
+    }
+    ```
+</Steps>
+
+## Working with Go Modules
+
+BAML integrates seamlessly with Go modules. Make sure your `go.mod` file includes the BAML dependency:
+
+```go go.mod
+module example.com/myproject
+
+go 1.21
+
+require (
+    github.com/boundaryml/baml v0.203.1
+)
+```
+
+The generated `baml_client` package will use your module path, so you can import it as:
+
+```go
+import (
+    b "example.com/myproject/baml_client"
+    "example.com/myproject/baml_client/types"
+)
+```
+
+## Context and Cancellation
+
+All BAML Go functions require a `context.Context` as the first parameter, allowing you to:
+
+```go
+// Set timeouts
+ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+defer cancel()
+
+result, err := b.ExtractResume(ctx, resume)
+
+// Handle cancellation
+ctx, cancel := context.WithCancel(context.Background())
+go func() {
+    time.Sleep(5 * time.Second)
+    cancel() // Cancel the request after 5 seconds
+}()
+
+result, err := b.ExtractResume(ctx, resume)
+if errors.Is(err, context.Canceled) {
+    fmt.Println("Request was canceled")
+}
+```
+
+You're all set! Continue on to the [Deployment Guides](/guide/development/deploying/docker) for your language to learn how to deploy your BAML code or check out the [Interactive Examples](https://baml-examples.vercel.app/) to see more examples.

fern/01-guide/03-development/deploying/docker.mdx

@@ -26,5 +26,12 @@ RUN npx baml-cli generate --from path-to-baml_src
 RUN bundle add baml
 RUN bundle exec baml-cli generate --from path/to/baml_src
 ```
+
+```dockerfile Go Dockerfile
+# Install Go and BAML CLI
+RUN go install github.com/boundaryml/baml/go/baml-cli@latest
+# Generate BAML client
+RUN baml-cli generate --from path-to-baml_src
+```
 </CodeBlocks>
 

fern/01-guide/03-development/terminal-logs.mdx

@@ -9,6 +9,35 @@ To enable logging, set the `BAML_LOG` environment variable:
 BAML_LOG=info
 ```
 
+<CodeBlocks>
+
+```go Go
+// Set logging level in Go application
+os.Setenv("BAML_LOG", "info")
+
+// Or run with environment variable:
+// BAML_LOG=info go run main.go
+```
+
+```python Python
+# Set logging level in Python
+import os
+os.environ["BAML_LOG"] = "info"
+
+# Or run with environment variable:
+# BAML_LOG=info python main.py
+```
+
+```typescript TypeScript
+// Set logging level in TypeScript/JavaScript
+process.env.BAML_LOG = "info";
+
+// Or run with environment variable:
+// BAML_LOG=info node main.js
+```
+
+</CodeBlocks>
+
 | Level | Description |
 |-------|-------------|
 | `error` | Fatal errors by BAML |
@@ -33,3 +62,40 @@ BOUNDARY_MAX_LOG_CHUNK_CHARS=3000
 ```
 
 This will truncate each part in a log entry to 3000 characters.
+
+<CodeBlocks>
+
+```go Go
+// Set log truncation in Go application
+os.Setenv("BOUNDARY_MAX_LOG_CHUNK_CHARS", "3000")
+
+// Example with both logging and truncation
+func main() {
+    // Configure logging
+    os.Setenv("BAML_LOG", "info")
+    os.Setenv("BOUNDARY_MAX_LOG_CHUNK_CHARS", "3000")
+    
+    // Your application code here
+}
+```
+
+```python Python
+# Set log truncation in Python
+import os
+os.environ["BOUNDARY_MAX_LOG_CHUNK_CHARS"] = "3000"
+
+# Example with both logging and truncation
+os.environ["BAML_LOG"] = "info"
+os.environ["BOUNDARY_MAX_LOG_CHUNK_CHARS"] = "3000"
+```
+
+```typescript TypeScript
+// Set log truncation in TypeScript/JavaScript
+process.env.BOUNDARY_MAX_LOG_CHUNK_CHARS = "3000";
+
+// Example with both logging and truncation
+process.env.BAML_LOG = "info";
+process.env.BOUNDARY_MAX_LOG_CHUNK_CHARS = "3000";
+```
+
+</CodeBlocks>

fern/01-guide/03-development/upgrade-baml-versions.mdx

@@ -12,7 +12,14 @@ generator TypescriptGenerator {
     output_type "typescript"
     ....
     // Version of runtime to generate code for (should match the package @boundaryml/baml version)
-    version "0.62.0"
+    version "0.205.0"
+}
+
+generator GoGenerator {
+    output_type "go"
+    ....
+    // Version of runtime to generate code for (should match the github.com/boundaryml/baml version)
+    version "0.205.0"
 }
 ```
 
@@ -30,6 +37,10 @@ npm install @boundaryml/baml@latest
 ```sh ruby
 gem install baml
 ```
+
+```sh go
+go get -u github.com/boundaryml/baml
+```
 </CodeBlock>
 
 3. Update VSCode BAML extension to point to the same version. Read here for how to keep VSCode in sync with your `baml_py` / `@boundaryml/baml` package dependency: [VSCode BAML Extension reference](/ref/editor-extension-settings/baml-cli-path)

fern/01-guide/04-baml-basics/concurrent-calls.mdx

@@ -77,6 +77,58 @@ if (require.main === module) {
 ```
 </Tab>
 
+<Tab title="Go">
+
+You can make concurrent `b.ClassifyMessage()` calls using goroutines:
+
+```go main.go
+package main
+
+import (
+    "context"
+    "sync"
+
+    b "example.com/myproject/baml_client"
+    "example.com/myproject/baml_client/types"
+)
+
+func main() {
+    ctx := context.Background()
+    
+    var wg sync.WaitGroup
+    results := make(chan types.Category, 2)
+    
+    // Launch concurrent goroutines
+    wg.Add(2)
+    
+    go func() {
+        defer wg.Done()
+        result, err := b.ClassifyMessage(ctx, "I want to cancel my order")
+        if err == nil {
+            results <- result
+        }
+    }()
+    
+    go func() {
+        defer wg.Done()
+        result, err := b.ClassifyMessage(ctx, "I want a refund")
+        if err == nil {
+            results <- result
+        }
+    }()
+    
+    wg.Wait()
+    close(results)
+    
+    // Collect results
+    for result := range results {
+        // Handle each result
+        _ = result
+    }
+}
+```
+</Tab>
+
 <Tab title="Ruby (beta)">
 
 BAML Ruby (beta) does not currently support async/concurrent calls.

fern/01-guide/04-baml-basics/error-handling.mdx

@@ -59,6 +59,11 @@ async function example() {
 
 ```
 
+```go Go
+// Error handling support coming soon for Go
+// Currently, Go functions return standard (non-typed) Go errors
+```
+
 ```ruby Ruby
 # Example coming soon
 ```